tuple - python prüfen ob zahl in liste




Wie überprüfe ich, ob eine Liste leer ist? (20)

Zum Beispiel, wenn Folgendes übergeben wird:

a = []

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


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.


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.


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

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

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

Ein anderer einfacher Weg könnte sein

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

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.


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


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.


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.


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.


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

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 .


Ab Python3 können Sie verwenden

 a = []
 try:
  print(a[-1])
 except IndexError:
  print("List is empty")

um zu überprüfen, ob die Liste leer ist

EDIT: Das funktioniert auch mit Python2.7.

Ich bin nicht sicher, warum es so viele komplizierte Antworten gibt. Es ist ziemlich klar und unkompliziert


Patricks (akzeptierte) Antwort ist richtig: if not a: ist der richtige Weg, dies zu tun. Die Antwort von Harley Holcombe stimmt, dass dies im PEP 8-Styleguide steht. Was aber keine der Antworten erklärt, ist, warum es eine gute Idee ist, der Redewendung zu folgen - selbst wenn Sie persönlich der Meinung sind, dass es für Ruby-Benutzer oder was auch immer nicht explizit genug oder verwirrend ist.

Python-Code und die Python-Community haben sehr starke Redewendungen. Wenn Sie diesen Redewendungen folgen, wird der Code für jeden, der mit Python vertraut ist, leichter lesbar. Wenn Sie diese Redewendungen verletzen, ist dies ein starkes Signal.

if not a: keine leeren Listen nicht von None oder numerischen 0 oder leeren Tupeln oder leeren, vom Benutzer erstellten Sammlungstypen oder leeren, vom Benutzer erstellten Nicht-Sammlungstypen oder einem NumPy-Array mit einem Element unterscheidet Als Skalare mit Falsey-Werten usw. fungieren. Manchmal ist es wichtig, dies explizit zu sagen. In diesem Fall wissen Sie, worüber Sie explizit sein möchten, damit Sie genau das testen können. Wenn beispielsweise if not a and a is not None: bedeutet dies "irgendetwas Falsey außer None", und if len(a) != 0: "nur leere Sequenzen bedeutet - und alles außer einer Sequenz ist hier ein Fehler", und so weiter . Neben dem Testen, was genau Sie testen möchten, signalisiert dies dem Leser, dass dieser Test wichtig ist.

Wenn Sie jedoch nichts explizites zu haben haben, führt alles, außer if not a: Irreführung des Lesers. Sie signalisieren etwas so Wichtiges, wenn es nicht so ist. (Möglicherweise machen Sie den Code auch weniger flexibel oder langsamer oder was auch immer, aber das ist alles weniger wichtig.) Und wenn Sie den Leser gewohnheitsmäßig auf diese Weise in die Irre führen, wird er, wenn Sie eine Unterscheidung treffen müssen, unbemerkt bleiben Sie haben überall im Code "Weinen" geweint.


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

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

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


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




is-empty