python zahl Wie überprüfe ich, ob eine Liste leer ist?




python prüfen ob zahl in liste (24)

Ich habe das Folgende als bevorzugt gesehen:

if not a:
    print("The list is empty or null")

Zum Beispiel, wenn Folgendes übergeben wird:

a = []

Wie überprüfe ich, ob a leer ist?


Einige Methoden, die ich verwende:

if not a:
    print "list is empty"


if len(a) == 0:
    print "list is empty"

Viele Antworten wurden gegeben und viele von ihnen sind ziemlich gut. Ich wollte nur den Scheck hinzufügen

not a

wird auch für Noneund andere Arten leerer Strukturen passen. Wenn Sie wirklich nach einer leeren Liste suchen möchten, können Sie Folgendes tun:

if isinstance(a, list) and len(a)==0:
    print("Received an empty list")

Hier können Sie überprüfen, ob eine Liste leer ist:

a = [] #the list

1) Der ziemlich einfache pythonische Weg:

if not a:
    print("a is empty")

In Python werden leere Container wie Listen, Tupel, Mengen, Diagramme, Variablen usw. als " False . Man könnte die Liste einfach als Prädikat behandeln ( einen booleschen Wert zurückgeben ). Ein True Wert würde bedeuten, dass er nicht leer ist.

2) Eine sehr explizite Methode: Verwenden Sie len() , um die Länge zu ermitteln und zu prüfen, ob sie gleich 0 :

if len(a) == 0:
    print("a is empty")

3) Oder mit einer anonymen leeren Liste vergleichen:

if a == []:
    print("a is empty")

4) Eine weitere, aber dumme Methode ist die Verwendung von exception und iter() :

try:
    next(iter(a))
    # list has elements
except StopIteration:
    print("Error: a is empty")

Ich hatte geschrieben:

if isinstance(a, (list, some, other, types, i, accept)) and not a:
    do_stuff

was wurde -1 gewählt. Ich bin mir nicht sicher, ob dies daran liegt, dass die Leser die Strategie ablehnten oder die Antwort als nicht hilfreich empfunden haben. Ich werde so tun, als sei es das letztere gewesen, da - was auch immer als "pythonisch" gilt - dies ist die richtige Strategie. Wenn Sie nicht bereits ausgeschlossen wurden oder bereit sind, Fälle zu behandeln, in denen a beispielsweise False , benötigen Sie einen Test, der restriktiver ist als nur if not a: Sie könnten so etwas 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 eine Antwort auf die Antwort von @ Mikes. Die dritte Zeile könnte auch ersetzt werden durch:

elif isinstance(a, (list, tuple)) and not a:

wenn Sie nur Instanzen bestimmter Typen (und ihrer Subtypen) akzeptieren möchten oder mit:

elif isinstance(a, (list, tuple)) and not len(a):

Sie können ohne explizite Typprüfung davonkommen, aber nur, wenn der umgebende Kontext Ihnen bereits sicherstellt, dass a ein Wert der Typen ist, für die Sie bereit sind, oder wenn Sie sicher sind, dass Typen, für die Sie nicht bereit sind, dies sind TypeError werden Fehler TypeError (z. B. ein TypeError wenn Sie len für einen Wert aufrufen, für den undefiniert ist), für den Sie bereit sind. Im Allgemeinen scheinen die "pythonischen" Konventionen diesen letzten Weg zu gehen. Drücken Sie es wie eine Ente und lassen Sie einen DuckError hochziehen, wenn er nicht weiß, wie man quatscht. Sie müssen jedoch noch darüber nachdenken, welche Art von Annahmen Sie machen, und ob die Fälle, mit denen Sie nicht richtig umgehen wollen, an den richtigen Stellen fehlerhaft sind. Die Numpy-Arrays sind ein gutes Beispiel dafür, dass das bloße Verlassen auf len oder die boolesche Typumsetzung möglicherweise nicht genau das tut, was Sie erwarten.


Eine leere Liste wird im True Value-Test selbst als falsch betrachtet (siehe Python-Dokumentation ):

a = []
if a:
     print "not empty"

@Daren Thomas

EDIT: Ein weiterer Punkt gegen das Testen der leeren Liste als False: Was ist mit Polymorphismus? Sie sollten sich nicht darauf verlassen, dass eine Liste eine Liste ist. Es sollte einfach wie eine Ente quaken - wie können Sie Ihre duckCollection dazu bringen, '' False '' zu quaken, wenn sie keine Elemente enthält?

Ihre duckCollection sollte __nonzero__ oder __len__ implementieren, damit if a: ohne Probleme funktioniert.


Auf einfache Weise wird geprüft, ob die Länge gleich Null ist.

if len(a) == 0:
    print("a is empty")

Sie können überprüfen, ob die Länge des Arrays Null ist (oder nicht.) Wenn die Länge des Arrays Null ist , ist es leer . Versuche Folgendes:

>>> a = []
>>> if a:
...     print "List is not empty";
... else:
...     print "List is empty"
... 
List is empty
>>> 
>>> a = [1, 4, 9]
>>> if a:
...     print "List is not empty";
... else:
...     print "List is empty"
... 
List is not empty
>>> 

Sehen Sie sich den folgenden Code an, der auf einem interaktiven Python-Terminal ausgeführt wird.

 >>> a = [] >>> if a: ... print "List is not empty"; ... else: ... print "List is empty" ... List is empty >>> >>> a = [1, 4, 9] >>> if a: ... print "List is not empty"; ... else: ... print "List is empty" ... List is not empty >>> 

Ein anderer einfacher Weg könnte sein

a = []
if len(a) == 0:
  print("Empty")
else:
  print(" Not empty")

Der pythonische Weg ist der PEP 8- Styleguide (wobei Ja bedeutet "empfohlen" und Nein bedeutet "nicht empfohlen"):

Verwenden Sie für Sequenzen (Strings, Listen, Tupel) die Tatsache, dass leere Sequenzen falsch sind.

Yes: if not seq:
     if seq:

No:  if len(seq):
     if not len(seq):

Sie können sogar versuchen, bool () so zu verwenden

    a = [1,2,3];
    print bool(a); # it will return True
    a = [];
    print bool(a); # it will return False

Ich liebe diesen Weg für die Checkliste ist leer oder nicht.

Sehr praktisch und nützlich.


Ich bevorzuge Folgendes:

if a == []:
   print "The list is empty."

Lesbar und Sie müssen sich keine Gedanken darüber machen, eine Funktion wie len() aufzurufen, um die Variable zu durchlaufen. Ich bin mir zwar nicht ganz sicher, was die BigO-Notation für so etwas ist ... aber Pythons so rasend schnell ich bezweifle, dass es eine Rolle spielt, es sei denn, a Gigant wäre riesig.


Ein inoffizieller Ansatz:

l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
    # do your stuff.

Aus documentation zum Wahrheitswerttest:

Alle anderen als die hier aufgeführten Werte werden als True

  • None
  • False
  • Null eines beliebigen numerischen Typs, zum Beispiel 0 , 0.0 , 0j .
  • eine beliebige leere Sequenz, zum Beispiel '' , () , [] .
  • eine leere Zuordnung, zum Beispiel {} .
  • Instanzen von benutzerdefinierten Klassen, wenn die Klasse eine __bool__() oder __len__() -Methode definiert, wenn diese Methode die Ganzzahl Null oder den Bool-Wert False zurückgibt.

Wie zu sehen ist, ist die leere Liste [] eine Fälschung , daher klingt es am effizientesten, was mit einem booleschen Wert gemacht wird:

if not a:
    print('"a" is empty!')

Wenn Sie prüfen möchten, ob die Liste leer ist.

def empty_list(lst):
    if len(lst) ==0:
        return false
    else:
        return all(bool(x) for x in l)

Wenn Sie das Wetter überprüfen möchten, sind alle Werte in der Liste leer.

if empty_list(lst):
    # do your stuff.

Dies gilt jedoch für eine leere Liste.

print('not empty' if a else 'empty')

Jetzt können Sie verwenden:

a.pop() if a else None

Ich ziehe es ausdrücklich vor:

if len(li) == 0:
    print('the list is empty')

Auf diese Weise ist 100% klar, dass li eine Sequenz (Liste) ist, und wir möchten deren Größe testen. Mein Problem mit if not li: ... ist der falsche Eindruck, dass li eine boolesche Variable ist.


a == []

etwas praktischer:

def is_empty(any_structure):
    if any_structure:
        print('Structure is not empty.')
        return True
    else:
        print('Structure is empty.')
        return False  

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

Manchmal ist es gut, auf None und Leerheit zu testen, da dies zwei verschiedene Zustände sind. Der obige Code erzeugt die folgende Ausgabe:

list is None 
list is empty 
list has 3 elements

Obwohl es nichts wert ist, ist None falsch. Wenn Sie also keinen Test auf Nicht-Sein trennen möchten, müssen Sie das nicht 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

Andere Leute scheinen die Frage jenseits von Listen zu verallgemeinern, also dachte ich, ich würde einen Vorbehalt für eine andere Art von Sequenz hinzufügen, die viele Leute verwenden könnten, zumal dies der erste Google-Hit für "Python Test Empty Array" ist. .

Andere Methoden funktionieren nicht für numpy Arrays

Sie müssen mit numpy-Arrays vorsichtig sein, da andere Methoden, die für Listens oder andere Standardcontainer gut geeignet sind, für numpy-Arrays fehlschlagen. Ich erkläre warum, aber kurz gesagt, die bevorzugte Methode ist die Verwendung der size .

Der "pythonic" Weg funktioniert nicht: Teil 1

Die "pythonic" -Methode schlägt mit numpy-Arrays fehl, weil numpy versucht, das Array in ein Array von bool Werten umzuwandeln, und if x versucht, alle diese bool Werte gleichzeitig auf eine Art Gesamtwahrheitswert zu prüfen. Das macht aber keinen Sinn, also 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()

Der "pythonic" Weg funktioniert nicht: Teil 2

Aber zumindest sagt der obige Fall, dass es fehlgeschlagen ist. Wenn Sie ein numpy-Array mit genau einem Element haben, funktioniert die if Anweisung in dem Sinne, dass Sie keinen Fehler erhalten. Wenn dieses eine Element jedoch 0 (oder 0.0 oder false , ...), führt die if -Anweisung falsch zu 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 wollten.

Die Verwendung von len kann zu unerwarteten Ergebnissen führen

Zum Beispiel,

len( numpy.zeros((1,0)) )

gibt 1 zurück, obwohl das Array keine Elemente enthält.

Der numpythonische Weg

Wie in den scipy-FAQs erläutert, ist die richtige Methode in allen Fällen, in denen Sie wissen, dass Sie ein numpy-Array haben, 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 sich um eine list , ein numpy-Array oder etwas anderes handelt, können Sie diesen Ansatz mit der Antwort @dubiousjim kombinieren, um sicherzustellen, dass für jeden Typ der richtige Test verwendet wird. Nicht sehr "pythonic", aber es stellt sich heraus, dass Numpy die Pythonicity zumindest in diesem Sinne absichtlich gebrochen hat.

Wenn Sie mehr als nur prüfen müssen, ob die Eingabe leer ist und Sie andere numpy-Funktionen wie Indizierung oder mathematische Operationen verwenden, ist es wahrscheinlich effizienter (und sicherlich häufiger), die Eingabe zu einem numpy-Array zu erzwingen. Es gibt ein paar nette Funktionen, um dies schnell zu numpy.asarray - vor allem numpy.asarray . Dies nimmt Ihre Eingabe in dtype , führt nichts aus, wenn es bereits ein Array ist, oder bündelt Ihre Eingabe in ein Array, wenn es sich um eine Liste, ein Tupel usw. handelt, und konvertiert sie optional in den von Ihnen ausgewählten dtype . Es ist also sehr schnell, wann immer es möglich ist, und es stellt sicher, dass Sie einfach davon ausgehen, dass die Eingabe ein numpy-Array ist. Normalerweise verwenden wir nur den gleichen Namen, da die Konvertierung in ein Array den aktuellen Bereich nicht scope :

x = numpy.asarray(x, dtype=numpy.double)

In allen Fällen, die auf dieser Seite x.size werden, x.size Überprüfung von x.size .


Am besten überprüfen Sie, ob eine Liste leer ist

Zum Beispiel, wenn Folgendes übergeben wird:

a = []

Wie überprüfe ich, ob a leer ist?

Kurze Antwort:

Platzieren Sie die Liste in einem booleschen Kontext (z. B. mit einer if oder while Anweisung). Wenn es leer ist, wird False getestet, andernfalls True . Zum Beispiel:

if not a:                           # do this!
    print('a is an empty list')

Appell an die Behörde

PEP 8 , der offizielle Python-Style-Guide für Python-Code in der Python-Standardbibliothek, behauptet:

Verwenden Sie für Sequenzen (Strings, Listen, Tupel) die Tatsache, dass leere Sequenzen falsch sind.

Yes: if not seq:
     if seq:

No: if len(seq):
    if not len(seq):

Wir sollten erwarten, dass Standard-Bibliothekscode so performant und korrekt wie möglich sein sollte. Aber warum ist das so und warum brauchen wir diese Anleitung?

Erläuterung

Ich sehe häufig Code wie diesen von erfahrenen Programmierern, die in Python neu sind:

if len(a) == 0:                     # Don't do this!
    print('a is an empty list')

Und Benutzer fauler Sprachen können versucht sein, dies zu tun:

if a == []:                         # Don't do this!
    print('a is an empty list')

Diese sind in ihren jeweiligen anderen Sprachen korrekt. Und das ist in Python sogar semantisch korrekt.

Wir halten es jedoch für un-Pythonic, da Python diese Semantik direkt in der Schnittstelle des Listenobjekts über booleschen Zwang unterstützt.

Aus den docs (und besonders die Einbeziehung der leeren Liste [] beachten):

Standardmäßig gilt ein Objekt als wahr, es sei denn, seine Klasse definiert entweder eine __bool__() Methode, die False zurückgibt, oder eine __len__() Methode, die beim Aufruf mit dem Objekt null zurückgibt. Die meisten eingebauten Objekte werden als falsch betrachtet:

  • Konstanten, die als falsch definiert sind: None und False .
  • Null eines beliebigen numerischen Typs: 0 , 0.0 , 0j , Decimal(0) , 0j Fraction(0, 1)
  • leere Sequenzen und Sammlungen: '' , () , [] , {} , set() , range(0)

Und die Datamodell-Dokumentation:

object.__bool__(self)

Wird aufgerufen, um den Wahrheitswerttest und die integrierte Operation bool() zu implementieren. sollte False oder True . Wenn diese Methode nicht definiert ist, wird __len__() aufgerufen, sofern sie definiert ist, und das Objekt wird als wahr betrachtet, wenn das Ergebnis ungleich Null ist. Wenn eine Klasse weder __len__() noch __bool__() , werden alle ihre Instanzen als wahr betrachtet.

und

object.__len__(self)

Wird aufgerufen, um die integrierte Funktion len() zu implementieren. Sollte die Länge des Objekts zurückgegeben werden, eine ganze Zahl> = 0. Außerdem gilt ein Objekt, das keine __bool__() Methode definiert und dessen __len__() Methode Null zurückgibt, in einem booleschen Kontext als falsch.

Also stattdessen:

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

Mach das:

if not a:
    print('a is an empty list')

Was Pythonic tut, zahlt sich in der Regel aus:

Lohnt es sich? (Beachten Sie, dass weniger Zeit für eine äquivalente Operation besser ist :)

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

Im Folgenden sind die Kosten für das Aufrufen der Funktion und das Erstellen und Zurückgeben einer leeren Liste aufgeführt, die Sie von den Kosten der oben verwendeten Leergutprüfung abziehen könnten:

>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342

Wir sehen, dass das Überprüfen der Länge mit der eingebauten Funktion len Vergleich zu 0 oder das Vergleichen mit einer leeren Liste viel weniger performant ist als die integrierte Syntax der Sprache, wie dokumentiert.

Warum?

Für die len(a) == 0 prüfen Sie:

Zuerst muss Python die Globals überprüfen, um zu sehen, ob len abgeschattet sind.

Dann muss es die Funktion aufrufen, 0 laden und den Gleichheitsvergleich in Python durchführen (anstelle von 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 das [] == [] es eine unnötige Liste erstellen und dann erneut die Vergleichsoperation in der virtuellen Maschine von Python durchführen (im Gegensatz zu C).

>>> dis.dis(lambda: [] == [])
  1           0 BUILD_LIST               0
              2 BUILD_LIST               0
              4 COMPARE_OP               2 (==)
              6 RETURN_VALUE

Die Methode "Pythonic" ist eine wesentlich einfachere und schnellere Überprüfung, da die Länge der Liste im Objektinstanzheader zwischengespeichert wird:

>>> dis.dis(lambda: not [])
  1           0 BUILD_LIST               0
              2 UNARY_NOT
              4 RETURN_VALUE

Nachweis aus der C-Quelle und Dokumentation

PyVarObject

Dies ist eine Erweiterung von PyObject , die das Feld PyObject hinzufügt. Dies wird nur für Objekte mit einem gewissen Längenbegriff verwendet. Dieser Typ wird in der Python / C-API nicht häufig angezeigt. Es entspricht den Feldern, die durch die Erweiterung des PyObject_VAR_HEAD Makros definiert werden.

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, dies zu recherchieren und verbringe viel Zeit damit, meine Antworten zu kuratieren. Wenn Sie glauben, dass ich etwas auslasse, lassen Sie es mich bitte in einem Kommentar wissen.


if not a:
  print("List is empty")

Die implizite Booleanität der leeren Liste zu verwenden, ist ziemlich pythonisch.


Warum überhaupt prüfen?

Niemand scheint sich mit der Frage zu befassen, dass Sie die Liste überhaupt erst testen müssen . Da Sie keinen zusätzlichen Kontext angegeben haben, kann ich mir vorstellen, dass Sie diese Prüfung möglicherweise gar nicht erst durchführen müssen, aber mit der Listenverarbeitung in Python nicht vertraut sind.

Ich würde sagen , dass der pythonischste Weg ist, überhaupt nicht zu prüfen, sondern nur die Liste zu verarbeiten. Auf diese Weise wird das Richtige getan, egal ob leer oder voll.

a = []

for item in a:
    <do something with item>

<rest of code>

Dies hat den Vorteil, dass Inhalte jeglicher Art behandelt werden, ohne dass eine spezifische Leergutprüfung erforderlich ist. Wenn a leer ist, wird der abhängige Block nicht ausgeführt und der Interpreter springt in die nächste Zeile.

Wenn Sie das Array tatsächlich auf Leerheit prüfen müssen, sind die anderen Antworten ausreichend.


Der Wahrheitswert einer leeren Liste ist, Falsewährend dies für eine nicht leere Liste gilt True.





is-empty