Wie kann ich überprüfen, ob eine Liste leer ist?
https://stackoverflow.com/questions/53513
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Zum Beispiel, wenn Sie überschritten wird, die folgenden:
a = []
Wie kann ich überprüfen, um zu sehen, ob a ist leer?
Lösung
if not a:
print("List is empty")
Über die implizite booleanness der leere list ist sehr pythonic.
Andere Tipps
Die pythonic Weg, es zu tun ist von der PEP 8 style guide (wo Ja bedeutet "empfohlen" und Keine bedeutet "nicht zu empfehlen"):
Für Sequenzen (strings, lists, tuples), verwenden Sie die Tatsache, dass leere Sequenzen sind falsch.
Ja: if not seq: if seq: No: if len(seq): if not len(seq):
Ich bevorzuge es ausdrücklich:
if len(li) == 0:
print('the list is empty')
Auf diese Weise ist es 100% klar, dass li ist eine Sequenz (Liste), und wir möchten zu testen Sie Ihre Größe.Mein problem mit if not li: ... ist, dass es gibt den falschen Eindruck, dass li ist eine Boolesche variable.
Andere Menschen scheinen Verallgemeinerung der Frage, die nicht nur die Listen, so dass ich dachte, ich würde einen VORBEHALT hinzufügen, die für eine andere Art von Sequenz, die eine Menge Leute verwenden könnten, zumal dies ist der erste google-Treffer für "python-test-empty-array".
Andere Methoden funktionieren nicht für NumPy-arrays
Sie müssen vorsichtig sein mit dem NumPy-arrays, da andere Methoden, die funktionieren lists oder andere standard-Container nicht für NumPy-arrays.Ich erkläre unten, warum, aber kurz gesagt, die bevorzugte Methode ist die Verwendung size.
Die "pythonic" Weg funktioniert nicht:Teil 1
Die "pythonic" Weg, schlägt mit NumPy arrays, da NumPy versucht, das wirken des Arrays zu einem array bools, und if x versucht zu bewerten, von denen bools auf einmal für einige Art von aggregierten Wahrheit Wert.Aber das macht auch keinen Sinn, so erhalten Sie einen ValueError:
>>> x = numpy.array([0,1])
>>> if x: print("x")
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
Die "pythonic" Weg funktioniert nicht:Teil 2
Aber zumindest der Fall oberhalb der Ihnen sagt, dass es fehlgeschlagen ist.Wenn Sie zufällig ein NumPy-array mit genau einem element, die if Aussage "arbeiten", in dem Sinne, dass Sie nicht erhalten eine Fehlermeldung.Allerdings, wenn Sie, dass ein element zufällig 0 (oder 0.0, oder False, ...), die if Anweisung fälschlicherweise dazu False:
>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x
Aber klar x existiert und ist nicht leer!Dieses Ergebnis ist nicht das, was Sie wollte.
Verwendung len kann zu unerwarteten Ergebnissen führen
Für Beispiel,
len( numpy.zeros((1,0)) )
gibt 1 zurück, auch wenn das array keine Elemente.
Die numpythonic Weg
Wie erklärt, in der SciPy FAQ, die richtige Methode in allen Fällen, in denen Sie wissen, dass Sie ein NumPy-array zu verwenden if x.size:
>>> x = numpy.array([0,1])
>>> if x.size: print("x")
x
>>> x = numpy.array([0,])
>>> if x.size: print("x")
... else: print("No x")
x
>>> x = numpy.zeros((1,0))
>>> if x.size: print("x")
... else: print("No x")
No x
Wenn Sie nicht sicher sind, ob es sein könnte list, ein NumPy-array oder etwas anderes, Sie könnte kombinieren diesen Ansatz mit die Antwort @dubiousjim gibt um sicherzustellen, dass der richtige test ist für jeden Typ.Nicht sehr "pythonic", aber es stellt sich heraus, dass NumPy absichtlich brach pythonicity in mindestens diesem Sinne.
Wenn Sie mehr tun müssen, als nur zu überprüfen, wenn die Eingabe leer ist, und du bist mit anderen NumPy-Funktionen wie Indizierung oder mathematische Operationen, ist es wahrscheinlich effizienter (und sicherlich häufiger) zu zwingen, die Eingang zu einen NumPy-array.Es gibt ein paar nette Funktionen, dies zu tun schnell — vor allem numpy.asarray.Dieser nimmt deinen input, tut nichts, wenn es bereits in einem array, oder wickelt Sie Ihre Eingabe in ein array, wenn es ist eine Liste, Tupel, etc., und, Optional, wandelt es um Ihre gewählte dtype.Es ist also sehr schnell, wenn es sein kann, und es wird sichergestellt, dass Sie nur zu übernehmen, die Eingabe aus einem NumPy-array.Wir in der Regel sogar nur den gleichen Namen, wie die Konvertierung in ein array wird nicht machen es zurück außerhalb des aktuellen Geltungsbereich:
x = numpy.asarray(x, dtype=numpy.double)
Dadurch wird der x.size prüfen Sie arbeiten in allen Fällen, die ich sehen auf dieser Seite.
Beste Weg, um zu überprüfen, ob eine Liste leer ist
Zum Beispiel, wenn Sie überschritten wird, die folgenden:
a = []Wie kann ich überprüfen, um zu sehen, wenn eine leer ist?
Kurze Antwort:
Platzieren Sie die Liste in einem booleschen Kontext (zum Beispiel, mit einem if oder while Anweisung).Es wird testen False wenn es leer ist, und True sonst.Zum Beispiel:
if not a: # do this!
print('a is an empty list')
Appell an Autorität
PEP 8, die offizielle Python style guide für Python-code in Python ' s standard library, behauptet:
Für Sequenzen (strings, lists, tuples), verwenden Sie die Tatsache, dass leere Sequenzen sind falsch.
Yes: if not seq: if seq: No: if len(seq): if not len(seq):
Wir sollten erwarten, dass standard-library-code sollte so schnell und korrekt wie möglich.Aber warum ist das der Fall, und warum brauchen wir diese Führung?
Erklärung
Ich Häufig sehen, code wie folgt aus erfahrenen Programmierern neu zu Python:
if len(a) == 0: # Don't do this!
print('a is an empty list')
Und Nutzer von faul Sprachen könnten versucht sein, dies zu tun:
if a == []: # Don't do this!
print('a is an empty list')
Diese sind richtig in Ihren jeweiligen anderen Sprachen.Und dies ist auch semantisch korrekt in Python.
Aber wir halten es für un-Pythonic, denn Python unterstützt diese Semantik direkt in der Liste Objekt-Schnittstelle über Boolesche Zwang.
Aus der docs (und beachten Sie insbesondere die Einbeziehung der leeren Liste, []):
Standardmäßig wird ein Objekt wird als wahr angesehen, wenn seine Klasse definiert entweder ein
__bool__()Methode, die zurückgibtFalseoder__len__()Methode , die null zurückgibt, wenn man es mit dem Objekt.Hier sind die meisten der built-in-Objekte als falsch:
- Konstanten definiert werden, false:
NoneundFalse.- null-beliebiger numerischer Typ:
0,0.0,0j,Decimal(0),Fraction(0, 1)- leere Sequenzen und Sammlungen:
'',(),[],{},set(),range(0)
Und das datamodel-Dokumentation:
Umzusetzen Wahrheit Wert testen und die gebaut-in Betrieb
bool();sollten zurückFalseoderTrue.Wenn diese Methode nicht definiert ist,__len__()wird aufgerufen, wenn Sie definiert ist, und das Objekt wird als wahr angesehen, wenn das Ergebnis ungleich null.Wenn eine Klasse definiert, weder__len__()noch__bool__(), alle seine Instanzen werden als wahr angesehen.
und
Aufgerufen zur Umsetzung der built-in Funktion
len().Sollte Rückkehr der Länge des Objekts, eine Ganzzahl >= 0.Auch ein Objekt, das nicht definieren__bool__()Methode und deren__len__()- Methode gibt null wird als false in a Boolean context.
Anstatt also diese:
if len(a) == 0: # Don't do this!
print('a is an empty list')
oder dieses:
if a == []: # Don't do this!
print('a is an empty list')
Tun Sie dies:
if not a:
print('a is an empty list')
Das tun, was Pythonic in der Regel zahlt der Leistung:
Zahlt Sie sich aus?(Beachten Sie, dass weniger Zeit zum ausführen eines gleichwertigen Betrieb ist besser:)
>>> import timeit
>>> min(timeit.repeat(lambda: len([]) == 0, repeat=100))
0.13775854044661884
>>> min(timeit.repeat(lambda: [] == [], repeat=100))
0.0984637276455409
>>> min(timeit.repeat(lambda: not [], repeat=100))
0.07878462291455435
Für die Skala, hier die Kosten für den Aufruf der Funktion und dem Bau und der Rückgabe eine leere Liste, die Sie könnte abziehen die Kosten von der leere, die Prüfungen, die oben verwendet wurden:
>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342
Wir sehen, dass entweder die überprüfung für die Länge mit der builtin-Funktion len im Vergleich zu 0 oder die Prüfung gegen eine leere Liste ist viel weniger performant als die vordefinierte syntax der Sprache dokumentiert.
Warum?
Für die len(a) == 0 check:
Erste Python hat, um überprüfen Sie die globals, um zu sehen, ob len ist schattiert.
Dann muss es die Funktion aufrufen, laden 0, und tun die Geschlechter-Vergleich in Python (statt mit C):
>>> import dis
>>> dis.dis(lambda: len([]) == 0)
1 0 LOAD_GLOBAL 0 (len)
2 BUILD_LIST 0
4 CALL_FUNCTION 1
6 LOAD_CONST 1 (0)
8 COMPARE_OP 2 (==)
10 RETURN_VALUE
Und für die [] == [] es hat zu bauen eine unnötige Liste und klicken Sie dann nochmals, den Vergleichsvorgang in Python virtual machine (im Gegensatz zu C)
>>> dis.dis(lambda: [] == [])
1 0 BUILD_LIST 0
2 BUILD_LIST 0
4 COMPARE_OP 2 (==)
6 RETURN_VALUE
Die "Pythonic" Weg ist eine viel einfacher und schneller überprüfen, da die Länge der Liste zwischengespeichert wird in der Objekt-Instanz-header:
>>> dis.dis(lambda: not [])
1 0 BUILD_LIST 0
2 UNARY_NOT
4 RETURN_VALUE
Nachweis von C-Quellcode und Dokumentation
Dies ist eine Erweiterung der
PyObjectfügt hinzu, dass dieob_sizeFeld.Das ist nur verwendet für Objekte, die eine gewisse Vorstellung von der Länge.Diese Art nicht oft erscheinen in der Python/C-API.Es entspricht den Feldern definiert, die durch die expansion derPyObject_VAR_HEADmakro.
Aus der c-Quelle in Include/listobject.h:
typedef struct {
PyObject_VAR_HEAD
/* Vector of pointers to list elements. list[0] is ob_item[0], etc. */
PyObject **ob_item;
/* ob_item contains space for 'allocated' elements. The number
* currently in use is ob_size.
* Invariants:
* 0 <= ob_size <= allocated
* len(list) == ob_size
Ich habe es genossen, die dies erforschen und ich verbringen viel Zeit kuratiert meine Antworten.Wenn Sie denken, ich bin etwas verlassen aus, lassen Sie es mich bitte in einem Kommentar wissen.
Eine leere Liste ist selbst in wahrem Wert Test falsch betrachtet (siehe python-Dokumentation ):
a = []
if a:
print "not empty"
@Daren Thomas
EDIT: Ein weiterer Punkt gegen Test die leere Liste als falsch: Was Polymorphismus? Sie sollten nicht davon abhängen, eine Liste ist eine Liste. Es sollte nur quaken wie eine Ente - wie werden Sie um Ihre duckCollection zu quaken '' False '', wenn es keine Elemente?
Ihre duckCollection sollte __nonzero__ oder __len__ so das, wenn eine Umsetzung: wird ohne Probleme funktionieren
Patrick (angenommen) Antwort hat Recht: if not a: der richtige Weg ist, es zu tun. Harley Holcombe Antwort ist richtig, dass dies in dem PEP 8 Style Guide ist. Aber was keiner der Antworten erklären ist, warum es eine gute Idee, das Idiom-even zu folgen, wenn Sie persönlich finde es ist nicht klar genug oder verwirrend Ruby Benutzer oder was auch immer.
Python-Code und die Python-Gemeinschaft, haben sehr starke Idiome. diese Idiome folgende macht den Code einfacher für jedermann in Python erlebt zu lesen. Und wenn Sie diese Idiome verletzen, das ist ein starkes Signal.
Es ist wahr, dass if not a: nicht leere Listen von None unterscheidet, oder numerisch 0 oder leere Tupel oder leer Benutzer erstellte Sammlung Typen oder leer Benutzer erstellen nicht-ganz-Sammlung Typen oder Einzelelement NumPy Array wie Skalare mit Falsey Werten handeln, etc. Und manchmal ist es wichtig, dass sein persönliches Vertrauen zu. Und in diesem Fall wissen Sie was Sie wollen über explizit sein, so können Sie sich für genau diese testen. Zum Beispiel bedeutet if not a and a is not None: „etwas Falsey außer None“, während if len(a) != 0: bedeutet „nur leere Sequenzen-und etwas anderes als eine Sequenz ein Fehler ist hier“, und so weiter. Neben Tests für genau das, was Sie testen wollen, signalisiert dies auch für den Leser, dass dieser Test wichtig ist.
Aber wenn Sie nichts tun müssen, Formulieren, etwas anderes als if not a: wird den Leser irreführend. Sie signalisiert etwas so wichtig, wenn es nicht ist. (Sie können auch den Code weniger flexibel werden machen, oder langsamer, oder was auch immer, aber das ist alles weniger wichtig ist.) Und wenn Sie gewöhnlich Irre führen den Leser wie dieses, dann, wenn Sie tun müssen einen Unterschied machen, es geht um unbemerkt passieren, weil Sie „crying Wolf“ am ganzen Code habe.
Warum überhaupt überprüfen?
scheint niemand angesprochen zu haben Ihre Notwendigkeit in Frage die Liste an erster Stelle zu testen. Weil Sie keinen zusätzlichen Kontext zur Verfügung gestellt, kann ich mir vorstellen, dass Sie diese Prüfung nicht in erster Linie tun müssen, aber nicht vertraut sind mit der Listenverarbeitung in Python.
Ich würde argumentieren, dass der die meisten pythonic Weg ist gar nicht zu prüfen, sondern nur die Liste verarbeiten. Auf diese Weise wird es das Richtige tun, ob leer oder voll ist.
a = []
for item in a:
<do something with item>
<rest of code>
Dies hat den Vorteil der Verarbeitung alle Inhalte von a , während keine spezielle Prüfung für Leere erfordern. Wenn a ist leer, der abhängige Block wird nicht ausgeführt, und der Dolmetscher wird durch in der nächsten Zeile fallen.
Wenn Sie wirklich brauchen das Array für Leere zu überprüfen, sind die anderen Antworten ausreichend.
len() ist ein O (1) Betrieb für Python Listen, Strings, dicts, und setzt. Python intern verfolgt die Anzahl der Elemente in diesen Containern.
Ich hatte geschrieben:
if isinstance(a, (list, some, other, types, i, accept)) and not a:
do_stuff
, die gewählt wurde -1. Ich bin mir nicht sicher, ob das, weil die Leser die Strategie widersprochen oder dachten, die Antwort nicht hilfreich war, wie dargestellt. Ich werde so tun, es letzteres war, da --- was als „pythonic“ zählt --- dies die richtige Strategie ist. Sofern Sie bereits entschieden haben, aus, oder sind bereit, Fälle zu behandeln, in denen a sind zum Beispiel False, benötigen Sie einen Test restriktiven als nur if not a:. Man könnte so etwas wie folgt verwenden:
if isinstance(a, numpy.ndarray) and not a.size:
do_stuff
elif isinstance(a, collections.Sized) and not a:
do_stuff
Der erste Test ist als Antwort auf @ Mike Antwort oben. Die dritte Zeile könnte auch ersetzt werden durch:
elif isinstance(a, (list, tuple)) and not a:
, wenn Sie nur Instanzen von bestimmten Typen akzeptieren (und deren Subtypen), oder mit:
elif isinstance(a, (list, tuple)) and not len(a):
Sie können ohne ausdrückliche Typprüfung weg, aber nur, wenn die umgebenden Kontext Sie bereits versichert, dass a ist ein Wert, der Typen, die Sie bereit sind, zu behandeln, oder wenn Sie sicher sind, dass Arten Sie sind nicht vorbereitet zu handhaben werden Fehler erhöhen (zB ein TypeError wenn Sie len auf einen Wert nennen, für die nicht definiert, es ist), die Sie bereit zu handhaben sind. Im Allgemeinen scheinen die „pythonic“ Konventionen diesen letzten Weg zu gehen. Drücken Sie es wie eine Ente und lassen Sie es eine DuckError erhöhen, wenn sie nicht weiß, wie quaken. Sie haben noch zu denken über welche Art Annahmen Sie machen, aber, und ob die Fälle sind Sie nicht bereit, richtig wirklich zu handhaben werden an den richtigen Stellen Fehler aus. Die Numpy Arrays sind ein gutes Beispiel, wo nur blind auf len oder boolean Typumwandlung unter Berufung kann nicht genau das tun, was Sie erwarten.
Dokumentation auf Wahrheitswert Prüfung:
Alle Werte außer dem, was hier aufgeführt werden als True
-
None -
False - Null von beliebigen numerischen Typs, zum Beispiel
0,0.0,0j. - jede leere Sequenz zum Beispiel
'',(),[]. - jede leere Abbildung zum Beispiel
{}. - Instanzen von benutzerdefinierten Klassen, ob die Klasse eine
__bool__()oder__len__()Methode definiert, wenn das Verfahren die ganze Zahl Null oder boolFalseWert zurückgibt.
Wie man sehen kann, leere Liste [] ist falsy , so zu tun, was zu einem Booleschen Wert getan würde klingt effizientesten:
if not a:
print('"a" is empty!')
Hier sind ein paar Möglichkeiten, wie Sie überprüfen, ob eine Liste leer ist:
a = [] #the list
1) Das ist ziemlich einfach pythonic Weise:
if not a:
print("a is empty")
In Python leere Container wie Listen, Tupel, Mengen, dicts, Variablen usw. werden als False gesehen. Man könnte einfach behandelt die Liste als Prädikat ( einen Booleschen Wert zurück ). Und ein True Wert würde bedeuten, dass es nicht leer ist.
2) Eine viel explizite Weise: die len() mit der Länge zu finden und überprüfen, ob es 0 gleich:
if len(a) == 0:
print("a is empty")
3) oder auf eine anonyme leere Liste Vergleich:
if a == []:
print("a is empty")
4) Ein anderer noch dumme Weg ist mit exception und iter() zu tun:
try:
next(iter(a))
# list has elements
except StopIteration:
print("Error: a is empty")
Ich ziehe es folgende Möglichkeiten:
if a == []:
print "The list is empty."
Methode 1 (bevorzugt):
if not a :
print ("Empty")
Methode 2:
if len(a) == 0 :
print( "Empty" )
Methode 3:
if a == [] :
print ("Empty")
def list_test (L):
if L is None : print 'list is None'
elif not L : print 'list is empty'
else: print 'list has %d elements' % len(L)
list_test(None)
list_test([])
list_test([1,2,3])
Es ist manchmal gut für None und Leere zu testen separat als diejenigen sind zwei verschiedene Zustände. Der obige Code erzeugt die folgende Ausgabe:
list is None
list is empty
list has 3 elements
Auch wenn es nichts wert ist, die None falsy ist. Also, wenn Sie nicht wollen, Test für None-ness zu trennen, müssen Sie nicht das tun.
def list_test2 (L):
if not L : print 'list is empty'
else: print 'list has %d elements' % len(L)
list_test2(None)
list_test2([])
list_test2([1,2,3])
produziert erwartet
list is empty
list is empty
list has 3 elements
Viele Antworten wurden gegeben worden, und viele von ihnen sind ziemlich gut. Ich wollte nur hinzufügen, dass der Scheck
not a
wird auch für None und andere Arten von leeren Strukturen bestehen. Wenn Sie wirklich für eine leere Liste überprüfen möchten, können Sie dies tun:
if isinstance(a, list) and len(a)==0:
print("Received an empty list")
inspiriert durch @ dubiousjim-Lösung, schlage ich eine zusätzliche allgemeine Überprüfung von verwenden, ob es etwas iterable
import collections
def is_empty(a):
return not a and isinstance(a, collections.Iterable)
Hinweis: ein String befindet iterable sein. - add and not isinstance(a,(str,unicode)), wenn Sie die leere Zeichenkette ausgeschlossen werden
Test:
>>> is_empty('sss')
False
>>> is_empty(555)
False
>>> is_empty(0)
False
>>> is_empty('')
True
>>> is_empty([3])
False
>>> is_empty([])
True
>>> is_empty({})
True
>>> is_empty(())
True
Sie können auch versuchen, Bool mit () wie folgt
a = [1,2,3];
print bool(a); # it will return True
a = [];
print bool(a); # it will return False
Ich liebe diese Art und Weise Liste zur Überprüfung leer ist oder nicht.
Sehr praktisch und nützlich.
Einfache Möglichkeit, die Länge ist die Überprüfung ist gleich Null.
if len(a) == 0:
print("a is empty")
print('not empty' if a else 'empty')
ein wenig praktische:
a.pop() if a else None
Von python3 ab können Sie
a == []
zu überprüfen, ob die Liste leer ist
EDIT: Das funktioniert mit python2.7 auch ..
Ich bin nicht sicher, warum es so viele komplizierte Antworten sind. Es ist ziemlich klar und einfach
könnten wir eine einfache verwenden, wenn sonst:
list=[]
if len(list)==0:
print ("list is empty")
else:
print ("list is not empty")
Verwenden Sie einfach is_empty () oder Schliesser wie: -
def is_empty(any_structure):
if any_structure:
print('Structure is not empty.')
return True
else:
print('Structure is empty.')
return False
Es kann für jede data_structure wie eine Liste, Tupel, Wörterbuch und viele mehr verwendet werden. Durch diese, können Sie es oft nur is_empty(any_structure) mit nennen.
Um zu überprüfen, ob eine Liste leer ist oder nicht, können Sie zwei folgenden Arten verwenden. Aber denken Sie daran, sollten wir die Art und Weise der explizit die Überprüfung für eine Sequenz oder Liste (es ist eine
less pythonicArt und Weise) vermeiden:
def Enquiry(list1):
if len(list1) == 0:
return 0
else:
return 1
# ––––––––––––––––––––––––––––––––
list1 = []
if Enquiry(list1):
print ("The list isn't empty")
else:
print("The list is Empty")
# Result: "The list is Empty".
Der zweite Weg ist ein
more pythonicein. Diese Methode ist eine implizite Möglichkeit der Überprüfung und vieles mehr bevorzugt als die vorherigen.
def Enquiry(list1):
if not list1:
return 1
else:
return 0
# ––––––––––––––––––––––––––––––––
list1 = []
if Enquiry(list1):
print ("The list is Empty")
else:
print ("The list isn't empty")
# Result: "The list is Empty"
Hope, das hilft.
Überprüfen Sie, ob: len(list) == 0 kehrt: True
Wenn Sie überprüfen wollen, ob die Liste leer ist;
l = []
if l:
# do your stuff.
Wenn Sie die Werte Wetter all Check-in-Liste leer ist.
l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
# do your stuff.
Dies wird jedoch für leere Liste wahr sein.
def empty_list(lst):
if len(lst) ==0:
return false
else:
return all(bool(x) for x in l)
Jetzt können Sie verwenden:
if empty_list(lst):
# do your stuff.
Der Wahrheitswert einer leeren Liste wird False während für eine nicht-leere Liste es True ist.
Was hat mich hier ist ein spezieller Anwendungsfall: Ich wollte eigentlich eine Funktion , mir zu sagen, ob eine Liste leer ist oder nicht. Ich wollte meine eigene Funktion oder mit einem Lambda-Ausdruck hier zu vermeiden, schreiben (weil es schien, als ob es einfach genug sein soll):
foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))
Und natürlich gibt es eine sehr natürliche Art und Weise, es zu tun:
foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))
Natürlich tun nicht Verwendung bool in if (das heißt, if bool(L):), weil es impliziert wird. Aber für die Fälle, in denen „nicht leer“ ist explizit als Funktion benötigt, bool ist die beste Wahl.
Eine doofe Art der Verwendung pop und try except Klausel (unrecommended):
a = []
try:
a.pop()
print('list isn\'t empty')
except:
print('list is empty')
Ausgabe:
list is empty
Ein inoffizieller Ansatz:
a = []
try:
print(a[-1])
except IndexError:
print("List is empty")
