Hoe controleer ik of een lijst leeg is?

Bijvoorbeeld, indien geslaagd voor het volgende:

a = []

Hoe controleer ik of aleeg is?

Antwoord 1, autoriteit 100%

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

De impliciete booleannessvan de lege listis nogal pythonisch.

Antwoord 2, autoriteit 21%

De pythonische manier om dit te doen is van de PEP 8-stijlgids( waarbij Ja“aanbevolen” betekent en Neebetekent “niet aanbevolen”):

Gebruik voor reeksen (strings, lijsten, tupels) het feit dat lege reeksen onwaar zijn.

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

Antwoord 3, autoriteit 14%

Ik geef er expliciet de voorkeur aan:

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

Op deze manier is het 100% duidelijk dat lieen reeks (lijst) is en we willen de grootte ervan testen. Mijn probleem met if not li: ...is dat het de verkeerde indruk wekt dat lieen booleaanse variabele is.

Antwoord 4

len()1) bewerkingvoor Python-lijsten, strings, dicts en sets. Python houdt intern het aantal elementen in deze containers bij.

JavaScript heeft een soortgelijk idee van waarheid/falsy.

Antwoord 5

Ik had geschreven:

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

die op -1 werd gestemd. Ik weet niet zeker of dat komt omdat lezers bezwaar maakten tegen de strategie of dachten dat het antwoord niet nuttig was zoals gepresenteerd. Ik zal net doen alsof het het laatste was, aangezien — wat ook telt als “pythonisch” — dit de juiste strategie is. Tenzij je al hebt uitgesloten of bereid bent gevallen aan te pakken waarin abijvoorbeeld Falseis, heb je een test nodig die restrictiever is dan alleen if not a:. Je zou zoiets als dit kunnen gebruiken:

if isinstance(a, numpy.ndarray) and not a.size:
    do_stuff
elif isinstance(a, collections.Sized) and not a:
    do_stuff

de eerste test is een reactie op het antwoord van @Mike hierboven. De derde regel kan ook worden vervangen door:

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

als u alleen instanties van bepaalde typen (en hun subtypen) wilt accepteren, of met:

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

Je kunt wegkomen zonder de expliciete typecontrole, maar alleen als de omringende context je al verzekert dat aeen waarde is van de typen die je aankan, of als je zeker weet die typen die u niet kunt verwerken, zullen fouten opleveren (bijv. een TypeErrorals u lenaanroept voor een waarde waarvoor deze niet is gedefinieerd) die u wel voorbereidt ermee omgaan. Over het algemeen lijken de “pythonische” conventies deze laatste kant op te gaan. Knijp erin als een eend en laat hem een DuckError opvoeden als hij niet weet hoe hij moet kwaken. Je moet echter nog steeds nadenkenover wat voor soort aannames je doet, en of de zaken die je niet goed kunt afhandelen, echt op de juiste plaatsen zullen mislukken. De Numpy-arrays zijn een goed voorbeeld waarbij blindelings vertrouwen op lenof de booleaanse typecast niet precies doet wat je verwacht.

Antwoord 6

Uit documentatieover het testen van de waarheidswaarde:

Alle andere waarden dan hier worden vermeld, worden als True

beschouwd

• None
• False
• nul van elk numeriek type, bijvoorbeeld 0, 0.0, 0j.
• Elke lege volgorde, bijvoorbeeld '', (), [].
• Elke lege mapping, bijvoorbeeld, {}.
• Instances van door de gebruiker gedefinieerde klassen, als de klasse een __bool__()of __len__()-methode, wanneer die methode de integer nul of boolwaarde False.

Zoals te zien is, is lege lijst []Falsy , dus doen wat er aan een booleaanse waarde wordt gedaan, klinkt het meest efficiënt:

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

7

Ik geef de voorkeur aan het volgende:

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

8

Hier zijn een paar manieren waarop u kunt controleren of een lijst leeg is:

a = [] #the list

1) De vrij eenvoudige pythonische manier:

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

In Python, lege containers zoals lijsten, tuples, sets, dicts, variabelen enz. worden gezien als False. Men kan de lijst eenvoudig behandelen als een predicaat (die een Booleaanse waarde retourneert). En een TrueWaarde zou aangeven dat het niet leeg is.

2) Een veel expliciete manier: met behulp van de len()om de lengte te vinden en te controleren of het gelijk is aan 0:

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

3) of vergelijking met een anonieme lege lijst:

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

4)Nog een dommemanier om dit te doen is het gebruik van exceptionen iter():

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

Antwoord 9

Methode 1 (voorkeur):

if not a : 
   print ("Empty") 

Methode 2:

if len(a) == 0 :
   print( "Empty" )

Methode 3:

if a == [] :
  print ("Empty")

Antwoord 10

Je kunt zelfs proberen om bool()op deze manier te gebruiken. Hoewel het minder leesbaar is, is het toch een beknopte manier om dit uit te voeren.

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

Ik hou van deze manier, want de checklist is leeg of niet.

Heel handig en nuttig.

Antwoord 11

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

Het is soms goed om afzonderlijk te testen op Noneen op leegte, aangezien dit twee verschillende toestanden zijn. De bovenstaande code produceert de volgende uitvoer:

list is None 
list is empty 
list has 3 elements

Hoewel het niets waard is dat Noneverval is. Dus als u geen test wilt scheiden voor None-ness, hoeft u dat niet te doen.

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

produceert verwachte

list is empty
list is empty
list has 3 elements

12

Veel antwoorden zijn gegeven, en veel van hen zijn redelijk goed. Ik wilde gewoon toevoegen dat de cheque

not a

passeert ook voor Noneen andere soorten lege structuren. Als u echt wilt controleren op een lege lijst, kunt u dit doen:

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

13

Als u wilt controleren of een lijst leeg is:

l = []
if l:
    # do your stuff.

Als u wilt controleren of alle waarden in de lijst leeg zijn. Het is echter Truevoor een lege lijst:

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

Als u beide gevallen samen wilt gebruiken:

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

Nu kunt u gebruiken:

if empty_list(lst):
    # do your stuff.

14

Geïnspireerd worden door de oplossing van @ Dubiousjim, stel ik voor om een ​​extra algemene controle van te gebruiken of het IT IT-ITERABELIG is

import collections
def is_empty(a):
    return not a and isinstance(a, collections.Iterable)

Opmerking: een tekenreeks wordt beschouwd als iespunt. – Voeg and not isinstance(a,(str,unicode))Als u wilt dat de lege tekenreeks

moet worden uitgesloten

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

15

We kunnen een eenvoudige indien anders gebruiken:

item_list=[]
if len(item_list) == 0:
    print("list is empty")
else:
    print("list is not empty")

16

Controleer of een lijst leeg is of niet, dan kunt u twee volgende manieren gebruiken. Maar vergeet niet dat we de weg moeten vermijden om expliciet te controleren op een type reeks (het is een less pythonicway):

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

De tweede manier is een more pythonicmanier. Deze methode is een impliciete manier van controleren en heeft veel meer de voorkeur dan de vorige.

def enquiry(list1): 
    if not list1: 
        return True
    else: 
        return False
# ––––––––––––––––––––––––––––––––
list1 = [] 
if enquiry(list1): 
    print ("The list is Empty") 
else: 
    print ("The list isn't empty") 
# Result: "The list is Empty"

Hopelijk helpt dit.

Antwoord 17

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

een beetje praktischer:

a.pop() if a else None

en meest pure versie:

if a: a.pop() 

Antwoord 18

Gebruik gewoon is_empty() of maak een functie zoals:-

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

Het kan worden gebruikt voor elke data_structure zoals een lijst, tupels, woordenboek en nog veel meer. Hierdoor kun je het vaak aanroepen met alleen is_empty(any_structure).

Antwoord 19

Een eenvoudige manier is om te controleren of de lengte gelijk is aan nul.

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

Antwoord 20

Vanaf python3 kun je

a == []

om te controleren of de lijst leeg is

EDIT: Dit werkt ook met python2.7..

Ik weet niet zeker waarom er zoveel ingewikkelde antwoorden zijn.
Het is vrij duidelijk en duidelijk

Antwoord 21

De waarheidswaarde van een lege lijst is Falseterwijl deze voor een niet-lege lijst Trueis.

Antwoord 22

Wat me hier bracht is een speciale use-case: ik wilde eigenlijk een functieom me te vertellen of een lijst leeg is of niet. Ik wilde vermijden om mijn eigen functie te schrijven of hier een lambda-expressie te gebruiken (omdat het leek alsof het eenvoudig genoeg zou moeten zijn):

foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))

En natuurlijk is er een heel natuurlijke manier om het te doen:

foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))

Natuurlijk, nietgebruik boolin if(dwz if bool(L):) omdat het geïmpliceerd is. Maar voor de gevallen waarin “is niet leeg” expliciet nodig is als functie, is boolde beste keuze.