Pythoniczny sposób na to jest z PEP 8 style guide (Gdzie Yes oznacza "zalecane", a No oznacza "nie zalecane"):

Dla sekwencji (ciągów, list, krotek), użyj faktu, że puste sekwencje są fałszywe.

Yes: if not seq:
     if seq:

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

Wolę to wprost:

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

W ten sposób jest w 100% Jasne, że li jest sekwencją (listą) i chcemy przetestować jej rozmiar. Mój problem z if not li: ... polega na tym, że daje fałszywe wrażenie, że {[1] } jest zmienną logiczną.

_{inni ludzie wydają się uogólniać pytanie poza tylko listy, więc pomyślałem, że dodam zastrzeżenie dla innego rodzaju sekwencji, że wiele osób może użyć, zwłaszcza, że jest to pierwszy hit google dla "python test pustej tablicy".}

Inne metody nie działają dla tablic numpy

Musisz być ostrożny z tablicami numpy, ponieważ inne metody, które działają dobrze dla list s lub innych standardowych kontenerów zawodzą dla tablic numpy. Wyjaśniam dlaczego poniżej, ale w skrócie, preferowaną metodą jest użycie size.

Sposób "pythoniczny" zawodzi z tablicami numpy, ponieważ numpy próbuje rzucić tablicę do tablicy bool s, a if x próbuje ocenić wszystkie te bool s na raz dla pewnego rodzaju zagregowanej wartości prawdy. Ale to nie ma sensu, więc dostajesz 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()

Sposób "pythoniczny" nie działa: część 2

Ale przynajmniej powyższy przypadek mówi, że nie udało się. Jeśli zdarzy ci się mieć tablicę numpy z dokładnie jednym elementem, Instrukcja if będzie "działać", w tym sensie, że nie otrzymasz błędu. Jeśli jednak ten jeden element jest 0 (lub 0.0, lub false,...), twierdzenie if będzie niepoprawnie wynikało z false:

>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x

Ale najwyraźniej x istnieje i nie jest pusty! Ten wynik nie jest tym, czego chciałeś.

Użycie len może dać nieoczekiwane wyniki

Na przykład,

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

Zwraca 1, mimo że tablica ma zero elementów.

The numpythonic way

Jak wyjaśniono w scipy FAQ, poprawną metodą we wszystkich przypadkach, w których wiesz, że masz tablicę numpy, jest użycie 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

Jeśli nie jesteś pewien, czy może to być list, tablica numpy, czy coś innego, możesz połączyć to podejście z odpowiedzią @dubiousjim daje, aby upewnić się, że odpowiedni test jest używany dla każdego typu. Niezbyt "pythoniczne", ale okazuje się, że numpy celowo złamał pythoniczność przynajmniej w tym sensie.

Jeśli musisz zrobić coś więcej niż tylko sprawdzić, czy dane wejściowe są puste, a używasz innych funkcji numpy, takich jak indeksowanie lub operacje matematyczne, prawdopodobnie bardziej wydajne (i na pewno bardziej powszechne) jest wymusić, aby wejście było tablicą numpy. Jest kilka fajnych funkcji do szybkiego wykonania tego zadania - co najważniejszenumpy.asarray. To pobiera dane wejściowe, nie robi nic, jeśli jest już tablicą, lub zawija dane wejściowe w tablica jeśli jest to lista, krotka, itp. i opcjonalnie zamienia go na wybrany dtype. Jest więc bardzo szybki, gdy tylko może być, i zapewnia, że po prostu można założyć, że wejście jest tablicą numpy. Zwykle używamy nawet tej samej nazwy, ponieważ konwersja do tablicy nie spowoduje powrotu poza bieżący zakres :

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

To sprawi, że sprawdzanie x.size będzie działać we wszystkich przypadkach, które widzę na tej stronie.

Pusta lista jest sama w sobie uważana za fałszywą w testowaniu wartości true (Zobacz Dokumentacja Pythona):

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

@Daren Thomas

EDIT: kolejny punkt przeciwko testowaniu pusta lista jako False: co z polimorfizm? Nie powinieneś polegać na lista jest listą. Powinno po prostu quack like a duck-how are you going by twoje kaczuszki kwakały "Fałszywy", gdy nie ma elementów?

Twój duckCollection powinien zaimplementować __nonzero__ lub __len__ więc if a: będzie działać bez problemów.

Najlepszy sposób, aby sprawdzić, czy lista jest pusta

Na przykład, jeśli przeszedł następujące:

a = []

Jak sprawdzić, czy a jest puste?

Krótka Odpowiedź:

Umieść listę w kontekście logicznym(na przykład za pomocą instrukcji if lub while). Sprawdzi False czy jest pusty, i True w przeciwnym razie. Na przykład:

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

Odwołanie się do władzy

PEP 8 , oficjalny przewodnik stylu Pythona dla kodu Pythona w Python ' s standard library, asserts:

Dla sekwencji (ciągów, list, krotek), użyj faktu, że puste sekwencje są fałszywe.

Yes: if not seq:
     if seq:

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

Powinniśmy oczekiwać, że standardowy kod biblioteki powinien być tak wydajny i poprawny, jak to tylko możliwe. Ale dlaczego tak jest i dlaczego potrzebujemy tych wskazówek?

Wyjaśnienie

Często widzę taki kod od doświadczonych programistów nowych w Pythonie:

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

I użytkownicy leniwych języków mogą być :

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

Są one poprawne w swoich innych językach. A to jest nawet semantycznie poprawne w Pythonie.

Ale uważamy to za nie-Pythoniczne, ponieważ Python obsługuje te semantyki bezpośrednio w interfejsie obiektu list poprzez Boolean coercion.

Z docs (i zwróć szczególną uwagę na włączenie pustej listy, []):

Domyślnie obiekt jest uważany za prawdziwy, chyba że jego klasa definiuje albo a __bool__() metoda zwracająca False lub metodę __len__() zwraca zero, gdy jest wywoływany z obiektem. Oto większość wbudowanych obiektów uważanych za fałszywe:

• stałe zdefiniowane jako false: None i False.
• zero dowolnego typu liczbowego: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• puste sekwencje i zbiory: '', (), [], {}, set(), range(0)

I dokumentacja datamodel:

object.__bool__(self)

Wezwany do wdrożenia testowania wartości prawdy i wbudowanej operacji bool(); powinien zwrócić False lub True. Gdy ta metoda nie jest zdefiniowana, __len__() jest wywołany, jeśli jest zdefiniowany, a obiekt jest uważany za prawdziwy, jeśli jego wynik jest niezerowy. Jeśli klasa nie definiuje ani __len__() ani __bool__(), wszystkie jego przypadki są uważane za prawdziwe.

I

object.__len__(self)

Wywołane do implementacji wbudowanej funkcji len(). Zwraca długość obiektu, liczbę całkowitą > = 0. Ponadto obiekt, który nie definiuje metody __bool__() i którego metoda __len__() zwraca zero, jest uważany za false w kontekście logicznym.

Więc zamiast tego:

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

Lub to:

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

Zrób to:

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

Robienie tego, co jest Pythoniczne Zwykle opłaca się w wykonaniu:

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

Dla scale, oto koszt wywołania funkcji oraz konstruowania i zwracania pustej listy, którą można odjąć od kosztów sprawdzania pustości użytej powyżej:

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

Widzimy, że albo sprawdzanie długości za pomocą wbudowanej funkcji len w porównaniu do 0 lub sprawdzanie pustej listy jest dużo mniej wydajne niż używanie wbudowanej składni języka, jak to udokumentowano.

Dla len(a) == 0 sprawdzić:

Najpierw Python musi sprawdzić globale, czy len jest cieniowany.

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

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

Sposób "Pythonic" jest o wiele prostszy i szybszy, ponieważ długość listy jest buforowana w nagłówek instancji obiektu:

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

Dowody ze źródła C i dokumentacja

PyVarObject

Jest to rozszerzenie PyObject, które dodaje pole ob_size. Jest to używane tylko dla obiektów, które mają pewne pojęcie długości. Ten typ nie pojawia się często w API Pythona / C. Odpowiada Polom zdefiniowanym przez rozszerzenie makra PyObject_VAR_HEAD.

Ze źródła c w 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

I cieszyłem się, badając to i spędzam dużo czasu na kuratorowaniu moich odpowiedzi. Jeśli uważasz, że coś pomijam, daj mi znać w komentarzu.

Odpowiedź Patryka (zaakceptowana) {[8] } jest słuszna: if not a: to właściwy sposób. Odpowiedź Harleya Holcombe ' a jest słuszna, że jest to w Przewodniku po stylu PEP 8. Ale żadna z odpowiedzi nie wyjaśnia, dlaczego dobrze jest podążać za idiomem-nawet jeśli osobiście stwierdzisz, że nie jest on wystarczająco wyraźny lub mylący dla użytkowników Ruby czy czegokolwiek innego.

Kod Pythona, a społeczność Pythona, ma bardzo silne idiomy. Podążanie za tymi idiomami sprawia, że kod jest łatwiejszy do odczytania dla każdego doświadczonego w Pythonie. A kiedy łamiesz te idiomy, to jest to silny sygnał.

To prawda, że if not a: nie odróżnia pustych list od None, ani liczb 0, ani pustych krotek, ani pustych typów kolekcji utworzonych przez użytkownika, ani pustych, nie do końca utworzonych przez użytkownika typów kolekcji, ani jednoelementowej tablicy NumPy działającej jako Skalary z wartościami falseya, itd. I czasami ważne jest, aby być o tym wyraźnym. I w takim przypadku, wiesz co {[16] } chcesz być szczery o, więc można przetestować na dokładnie to. Na przykład if not a and a is not None: oznacza "wszystko fałsz, z wyjątkiem żadnego", podczas gdy if len(a) != 0: oznacza "tylko puste sekwencje-i wszystko poza sekwencją jest tutaj błędem", i tak dalej. Poza testowaniem dokładnie tego, co chcesz przetestować, sygnalizuje to również czytelnikowi, że ten test jest ważny.

Ale kiedy nie masz nic do powiedzenia, cokolwiek innego niż if not a: wprowadza czytelnika w błąd. Sygnalizujesz coś równie ważnego, gdy nie jest. (możesz też sprawić, że kod będzie mniej elastyczny, wolniejszy, czy cokolwiek, ale to wszystko jest mniej ważne.) I jeśli zwyczajowo wprowadzasz czytelnika w błąd w ten sposób, to kiedy } będziesz musiał dokonać rozróżnienia, przejdzie to niezauważone, ponieważ byłeś "płaczącym wilkiem" w całym swoim kodzie.

Widziałem poniżej jako preferowane:

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

Po co w ogóle sprawdzać?

Wydaje się, że nikt nie zwrócił się do Ciebie z pytaniem o Twoją potrzebę , aby przetestować listę w pierwszej kolejności. Ponieważ nie podałeś żadnego dodatkowego kontekstu, mogę sobie wyobrazić, że może nie musisz tego sprawdzać w pierwszej kolejności, ale nie jesteś zaznajomiony z przetwarzaniem list w Pythonie.

Argumentowałbym, że najbardziej pythonicznym sposobem jest nie Sprawdzanie w ogóle, ale raczej przetwarzanie listy. W ten sposób zrobi to, co właściwe, czy będzie puste, czy pełny.

a = []

for item in a:
    <do something with item>

<rest of code>

Ma to tę zaletę, że radzi sobie z dowolną zawartością a , nie wymagając przy tym szczególnej kontroli pustki. Jeśli a jest pusty, zależny blok nie zostanie uruchomiony i interpreter przejdzie do następnej linii.

Jeśli rzeczywiście musisz sprawdzić tablicę pod kątem pustki, Pozostałe odpowiedzi są wystarczające.

len() jest operacją O (1) Dla list, łańcuchów, dictów i zestawów Pythona. Python wewnętrznie śledzi liczbę elementów w tych kontenerach.

JavaScript ma podobne pojęcie prawdziwości / fałszu .

Napisałem:

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

, który został wybrany -1. Nie jestem pewien, czy to dlatego, że czytelnicy sprzeciwili się strategii lub uważali, że odpowiedź nie była pomocna, jak przedstawiono. Będę udawać, że to drugie, ponieważ - - - cokolwiek liczy się jako "pythonic" - - - to jest właściwa strategia. Jeśli już wykluczyłeś lub jesteś przygotowany do obsługi przypadków, w których a jest, na przykład, False, potrzebujesz testu bardziej restrykcyjnego niż tylko if not a:. Przydałoby się coś takiego:

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

Pierwszy test jest w odpowiedzi na odpowiedź @Mike, powyżej. Trzecia linia może być również zastąpiona przez:

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

Jeśli chcesz akceptować tylko instancje poszczególnych typów (i ich podtypy), lub za pomocą:

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

Można uciec bez jawnego sprawdzania typu, ale tylko wtedy, gdy otaczający kontekst już zapewnia, że a jest wartością typów, z którymi jesteś przygotowany do obsługi, lub jeśli jesteś pewien, że typy, z którymi nie jesteś przygotowany do obsługi, spowodują błędy (np. len na wartość, dla której jest niezdefiniowana), którą jesteś gotowy obsłużyć. Ogólnie rzecz biorąc, konwencje "pythoniczne" zdają się iść tą ostatnią drogą. Ściśnij go jak kaczkę i niech podniesie DuckError, jeśli nie umie kwakać. Nadal musisz pomyśleć o tym, jakie założenia stawiasz, i czy sprawy, które nie jesteś przygotowany do właściwego postępowania, naprawdę się mylą we właściwych miejscach. Tablice Numpy są dobrym przykładem, gdzie po prostu ślepo opierając się na len lub Typ boolean może nie robić dokładnie tego, czego oczekujesz.

Python jest bardzo jednorodny w leczeniu pustki.

a = []

.
.
.

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

Po prostu sprawdzasz listę a za pomocą polecenia "if", aby sprawdzić, czy jest pusta. Z tego, co przeczytałem i zostałem nauczony, jest to sposób "Pythoniczny", aby sprawdzić, czy lista lub krotka jest pusta.

Niektóre metody, których używam:

if not a:
    print "list is empty"


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

Z dokumentacji o testowaniu wartości prawdy:

Wszystkie wartości inne niż wymienione tutaj są uważane za True

• None
• False
• zero dowolnego typu liczbowego, na przykład, 0, 0.0, 0j.
• dowolny ciąg pusty, na przykład, '', (), [].
• dowolne puste mapowanie, na przykład {}.
• instancje klas zdefiniowanych przez użytkownika, jeśli klasa definiuje metodę __bool__() lub __len__(), Gdy ta metoda zwraca liczba całkowita zero lub wartość bool False.

Jak widać, pusta lista [] jest falsy , więc robienie tego, co byłoby zrobione z wartością logiczną, brzmi najefektywniej:

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

Oto kilka sposobów na sprawdzenie, czy lista jest pusta:

a = [] #the list

1) dość prosty sposób pythoniczny:

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

W Pythonie, puste kontenery takie jak listy,krotki,zestawy,dicty,zmienne itp.są postrzegane jako False. Można po prostu traktować listę jako predykat (zwracający wartość logiczną ). Wartość True oznaczałaby, że nie jest pusta.

2) bardzo wyraźny sposób: używając len(), aby znaleźć długość i sprawdzić, czy równa się 0:

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

3) lub porównując go do anonimowej pustej listy:

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

4) Jeszcze jeden głupi sposób to użycie exception i iter():

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

Preferuję:

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

Readable i nie musisz się martwić wywołaniem funkcji takiej jak len() do iteracji przez zmienną. Chociaż nie jestem do końca pewien, co to jest BigO zapis czegoś takiego... ale Python jest tak niesamowicie szybki, że wątpię, by miało to znaczenie, gdyby nie był gigantyczny.

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

Czasami dobrze jest przetestować oddzielnie dla None i dla pustki, ponieważ są to dwa różne stany. Powyższy kod daje następujące wyjście:

list is None 
list is empty 
list has 3 elements

Chociaż nie jest nic warte to None jest fałszywe. Więc jeśli nie chcesz oddzielać testu dla None - ness, nie musisz tego robić.

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

Produkuje oczekiwane

list is empty
list is empty
list has 3 elements

Innym prostym sposobem może być

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

Możesz nawet spróbować użyć BooL () w ten sposób

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

Uwielbiam ten sposób sprawdzania, czy lista jest pusta, czy nie.

Zainspirowany rozwiązaniem @ dubiousjim, proponuję użyć dodatkowego ogólnego sprawdzenia, czy jest to coś iterowalnego

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

Uwaga: łańcuch jest uważany za iterowalny. - dodaj and not isinstance(a,(str,unicode)) jeśli chcesz, aby pusty łańcuch był wykluczony

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

Jeśli chcesz sprawdzić, czy lista jest pusta;

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

Jeśli chcesz sprawdzić pogodę wszystkie wartości na liście są puste.

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

Będzie to jednak prawdą dla pustej listy.

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

Teraz możesz użyć:

if empty_list(lst):
    # do your stuff.

Wartość prawdy pustej listy wynosi False, podczas gdy dla niepustej listy jest to True.

Po prostu użyj is_empty () lub wykonaj funkcję podobną do:-

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

Może być używany dla dowolnych data_struktura, takich jak lista, krotki, słownik i wiele innych. Przez to można nazwać go wiele razy używając tylko is_empty(any_structure).

Nieoficjalne podejście:

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

Spójrz na poniższy kod wykonywany na interaktywnym terminalu Pythona.

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

Myślę, że ludzie zasugerowali dla

if len(list1) == 0:
    print("is a good way")

Lub len możesz liczyć przez

if list1.__ len__()==0:
    print("list1 is empty")

Możesz użyć jeszcze jednej drogi

if list1.__ sizeof__() == 40:
    print("list1 is empty")

Rozmiar pustej listy to zawsze 40.

Możesz po prostu zrobić:

lst = []
any(lst)   ##this returns False