Например, если передано следующее:

a = []

Как проверить, aпусто ли?

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

Использование неявного булева пустоты listдовольно питонно.

Pythonic способ сделать это из руководства по стилю PEP 8 (где Да означает «рекомендуется», а Нет означает «не рекомендуется»):

Для последовательностей (строк, списков, кортежей) используйте тот факт, что пустые последовательности являются ложными.

Yes: if not seq:
     if seq:

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

Я предпочитаю это явно:

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

Таким образом, на 100% ясно, что liэто последовательность (список), и мы хотим проверить ее размер. Моя проблема в if not li: ...том, что это создает ложное впечатление, что liэто логическая переменная.

_{Это первый хит Google для "пустого массива python test" и аналогичных запросов, плюс другие люди, кажется, обобщают вопрос за пределы списков, поэтому я решил добавить предостережение для последовательности другого типа, которую многие люди может использовать.}

Другие методы не работают для массивов NumPy

Вы должны быть осторожны с массивами NumPy, потому что другие методы, которые отлично работают для lists или других стандартных контейнеров, не работают для массивов NumPy. Я объясню, почему ниже, но вкратце, предпочтительным методом является использование size.

«Питонический» способ не работает: часть 1

«Питонический» путь терпит неудачу с массивами NumPy, потому что NumPy пытается привести массив к массиву bools и if xпытается оценить все эти bools одновременно для некоторого совокупного значения истинности. Но это не имеет никакого смысла, поэтому вы получите 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()

«Питонический» способ не работает: часть 2

Но, по крайней мере, приведенный выше случай говорит вам, что это не удалось. Если у вас есть массив NumPy с ровно одним элементом, ifоператор будет «работать» в том смысле, что вы не получите ошибку. Тем не менее, если этот один элемент окажется 0(или 0.0, или False, ...), ifоператор будет неправильно привести к False:

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

Но явно xсуществует и не пусто! Этот результат не то, что вы хотели.

Использование lenможет дать неожиданные результаты

Например,

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

возвращает 1, даже если массив содержит ноль элементов.

Numpythonic способ

Как объясняется в SciPy FAQ , правильный метод во всех случаях, когда вы знаете, что у вас есть массив NumPy, должен использовать 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

Если вы не уверены, что это может быть listмассив NumPy или что-то еще, вы можете объединить этот подход с ответом, который дает @dubiousjim, чтобы убедиться, что для каждого типа используется правильный тест. Не очень "pythonic", но оказывается, что NumPy преднамеренно нарушил pythonicity по крайней мере в этом смысле.

Если вам нужно сделать больше, чем просто проверить, является ли ввод пустым, и вы используете другие функции NumPy, такие как индексирование или математические операции, возможно, более эффективно (и, безусловно, более распространено), чтобы входные данные были массивом NumPy. Есть несколько хороших функций для быстрого выполнения этого - самое главное numpy.asarray. Он принимает ваш ввод, ничего не делает, если он уже является массивом, или упаковывает ваш ввод в массив, если это список, кортеж и т. Д., И при желании преобразует его в выбранный вами dtype. Так что это очень быстро, когда это возможно, и гарантирует, что вы просто предполагаете, что входные данные являются массивом NumPy. Обычно мы даже просто используем одно и то же имя, поскольку преобразование в массив не вернет его за пределы текущей области :

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

Это сделает x.sizeпроверку работоспособной во всех случаях, которые я вижу на этой странице.

Лучший способ проверить, если список пуст

Например, если передано следующее:

a = []

Как проверить, пусто ли?

Короткий ответ:

Поместите список в логический контекст (например, с помощью оператора ifили while). Он проверит, Falseесли он пуст, и в Trueпротивном случае. Например:

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

ПКП 8

PEP 8 , официальное руководство по стилю Python для кода Python в стандартной библиотеке Python, утверждает:

Для последовательностей (строк, списков, кортежей) используйте тот факт, что пустые последовательности являются ложными.

Yes: if not seq:
     if seq:

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

Мы должны ожидать, что код стандартной библиотеки должен быть максимально быстрым и корректным. Но почему это так, и зачем нам это руководство?

объяснение

Я часто вижу подобный код от опытных программистов, плохо знакомых с Python:

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

А у пользователей ленивых языков может возникнуть соблазн сделать это:

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

Они верны на других языках. И это даже семантически правильно в Python.

Но мы считаем, что это не Pythonic, потому что Python поддерживает эту семантику непосредственно в интерфейсе объекта списка посредством логического приведения.

Из документов (и обратите особое внимание на включение пустого списка []):

По умолчанию объект считается истинным, если только его класс не определяет либо __bool__()метод, который возвращает, Falseлибо __len__()метод, который возвращает ноль, когда вызывается с объектом. Вот большинство встроенных объектов, которые считаются ложными:

• константы, определенные как ложные: Noneи False.
• ноль любого числового типа: 0, 0.0, 0j, Decimal(0),Fraction(0, 1)
• пустые последовательности и коллекции: '', (), [], {}, set(),range(0)

И документация по датамоделю:

object.__bool__(self)

Вызывается для выполнения проверки истинности значения и встроенной операции bool(); должен вернуться Falseили True. Когда этот метод не определен, __len__()вызывается, если он определен, и объект считается истинным, если его результат ненулевой. Если класс не определяет ни то, __len__() ни другое __bool__(), все его экземпляры считаются истинными.

а также

object.__len__(self)

Вызывается для реализации встроенной функции len(). Должен возвращать длину объекта, целое число> = 0. Кроме того, объект, который не определяет __bool__()метод и чей __len__()метод возвращает ноль, считается ложным в логическом контексте.

Итак, вместо этого:

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

или это:

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

Сделай это:

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

То, что делает Pythonic, обычно окупается в исполнении:

Это окупается? (Обратите внимание, что чем меньше времени для выполнения эквивалентной операции, тем лучше :)

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

Для масштаба вот стоимость вызова функции, создания и возврата пустого списка, который вы можете вычесть из стоимости проверок пустоты, использованной выше:

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

Мы видим, что либо проверка длины с помощью встроенной функции lenпо сравнению с пустым списком, 0 либо проверка по пустому списку гораздо менее производительны, чем использование встроенного синтаксиса языка, как описано в документации.

Почему?

Для len(a) == 0проверки:

Во-первых, Python должен проверить глобальные переменные, чтобы увидеть, lenне скрыт ли.

Затем он должен вызвать функцию, загрузить 0и выполнить сравнение на равенство в Python (вместо 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

И для этого [] == []он должен создать ненужный список, а затем снова выполнить операцию сравнения на виртуальной машине Python (в отличие от C)

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

«Pythonic» - намного более простая и быстрая проверка, поскольку длина списка кэшируется в заголовке экземпляра объекта:

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

Данные из источника C и документации

PyVarObject

Это расширение, PyObjectкоторое добавляет ob_sizeполе. Это используется только для объектов, которые имеют некоторое представление о длине. Этот тип не часто появляется в Python / C API. Это соответствует полям, определенным расширением PyObject_VAR_HEADмакроса.

Из c источника в 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

Ответ на комментарии:

Я хотел бы отметить, что это также верно для непустого случая, хотя он довольно уродлив, как l=[]тогда %timeit len(l) != 090,6 нс ± 8,3 нс, %timeit l != []55,6 нс ± 3,09, %timeit not not l38,5 нс ± 0,372. Но никто не получит удовольствия, not not lнесмотря на тройную скорость. Это выглядит смешно. Но скорость выигрывает,
я полагаю, что проблема заключается в тестировании со временем, так как просто if l:достаточно, но неожиданно %timeit bool(l)дает 101 нс ± 2,64 нс. Интересно, что без этого наказания невозможно навязать бул. %timeit lбесполезен, так как никакого преобразования не произойдет.

Волшебство IPython %timeit, здесь не совсем бесполезно:

In [1]: l = []                                                                  

In [2]: %timeit l                                                               
20 ns ± 0.155 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

In [3]: %timeit not l                                                           
24.4 ns ± 1.58 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [4]: %timeit not not l                                                       
30.1 ns ± 2.16 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Мы можем видеть, что есть немного линейной стоимости для каждого дополнительного notздесь. Мы хотим видеть затраты, при прочих равных условиях , то есть при прочих равных условиях , где все остальное сводится к минимуму, насколько это возможно:

In [5]: %timeit if l: pass                                                      
22.6 ns ± 0.963 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [6]: %timeit if not l: pass                                                  
24.4 ns ± 0.796 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [7]: %timeit if not not l: pass                                              
23.4 ns ± 0.793 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Теперь давайте посмотрим на случай списка безработных:

In [8]: l = [1]                                                                 

In [9]: %timeit if l: pass                                                      
23.7 ns ± 1.06 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [10]: %timeit if not l: pass                                                 
23.6 ns ± 1.64 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [11]: %timeit if not not l: pass                                             
26.3 ns ± 1 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Здесь мы видим, что не имеет большого значения, передаете ли вы фактическую boolпроверку состояния или сам список, и, если что-то, предоставление списка, как есть, происходит быстрее.

Python написан на C; он использует свою логику на уровне C. Все, что вы пишете на Python, будет медленнее. И это, вероятно, будет на несколько порядков медленнее, если вы не используете механизмы, встроенные непосредственно в Python.

Пустой список сам по себе считается ложным в тестировании истинного значения (см. Документацию по Python ):

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

@ Дарен Томас

РЕДАКТИРОВАТЬ: Еще одно замечание против проверки пустого списка как False: Как насчет полиморфизма? Вы не должны зависеть от списка, являющегося списком. Он должен просто крякать, как утка - как вы собираетесь заставить свой duckCollection крякать «Ложь», когда в нем нет элементов?

Ваша duckCollection должна реализовать __nonzero__или __len__так, если: будет работать без проблем.

Ответ Патрика (принятый) правильный: if not a:это правильный способ сделать это. Правильный ответ Харли Холкомба - это руководство по стилю PEP 8. Но то, что ни один из ответов не объясняет, - это то, почему стоит следовать этой идиоме, даже если вы лично обнаружите, что она недостаточно ясна или сбивает с толку пользователей Ruby или чего-либо еще.

Код Python и сообщество Python имеют очень сильные идиомы. Следование этим идиомам делает ваш код более легким для чтения для всех, кто имеет опыт работы с Python. И когда вы нарушаете эти идиомы, это сильный сигнал.

Это правда, что if not a:он не различает пустые списки от Noneили числового 0, или пустые кортежи, или пустые типы коллекций, созданные пользователем, или пустые созданные пользователем типы не совсем коллекции, или одноэлементный массив NumPy, действующий как скаляры с Falsey ценности и т. д. И иногда важно четко об этом говорить. И в этом случае вы знаете, о чем хотите быть явным, поэтому вы можете проверить именно это. Например, if not a and a is not None:означает «что-нибудь фальшивое, кроме None», а if len(a) != 0:означает «только пустые последовательности - и все, кроме последовательности, является здесь ошибкой», и так далее. Помимо тестирования именно того, что вы хотите проверить, это также сигнализирует читателю, что этот тест важен.

Но когда вам нечего прямо выражать, ничего, кроме того, if not a:что вводит читателя в заблуждение. Вы сигнализируете о чем-то важном, когда это не так. (Вы можете также сделать код менее гибким, или медленнее, или любой другой , но это все , что менее важно.) И если вы постоянно вводить читателя в заблуждение , как это, тогда , когда вы делаете потребность сделать различие, это будет проходить незамеченным , потому что ты был "плачущим волком" по всему твоему коду.

Зачем вообще проверять?

Похоже, никто не обращался с вопросом о том, нужно ли вам сначала проверять список. Поскольку вы не предоставили никакого дополнительного контекста, я могу себе представить, что вам может не понадобиться делать эту проверку, но вы не знакомы с обработкой списков в Python.

Я бы сказал, что самый питонический способ - это вообще не проверять, а просто обрабатывать список. Таким образом, он будет делать правильные вещи, будь то пустой или полный.

a = []

for item in a:
    <do something with item>

<rest of code>

Это имеет преимущество обработки любого содержимого , не требуя проверки конкретной для пустоты. Если a пусто, зависимый блок не будет выполнен, и интерпретатор перейдет к следующей строке.

Если вам действительно нужно проверить массив на пустоту, других ответов достаточно.

len() является операцией O (1) для списков Python, строк, диктов и множеств. Python внутренне отслеживает количество элементов в этих контейнерах.

У JavaScript есть похожее понятие истина / ложь .

Я написал:

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

за который проголосовали -1. Я не уверен, что это потому, что читатели возражали против стратегии или считали, что ответ не был полезен в представленном виде. Я буду притворяться, что это последнее, поскольку - что бы ни считалось "питоническим" - это правильная стратегия. Если вы уже не исключили или не готовы обрабатывать случаи a, например False, вам нужен тест, более ограничивающий, чем просто if not a:. Вы можете использовать что-то вроде этого:

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

первый тест в ответ на ответ @ Mike, выше. Третья строка также может быть заменена на:

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

если вы хотите принимать только экземпляры определенных типов (и их подтипов) или с помощью:

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

Вы можете обойтись без явной проверки типов, но только в том случае, если окружающий контекст уже заверяет вас, что aэто значение типов, которые вы готовы обработать, или если вы уверены, что типы, которые вы не готовы обрабатывать, собираются выдавать ошибки (например, TypeErrorесли вы вызываете lenзначение, для которого оно не определено), которое вы готовы обработать. В общем, "питонические" соглашения, кажется, идут этим последним путем. Сожмите его, как утку, и дайте ему поднять ошибку DuckError, если он не знает, как крякать. Вы все равно должны это сделать, подумать о том, какие допущения типов вы делаете, и действительно ли ошибки, которые вы не готовы обрабатывать должным образом, будут приводить к ошибкам в нужных местах. Массивы Numpy являются хорошим примером, когда просто слепо полагаться наlen или тип логического типа может не выполнять то, что вы ожидаете.

Из документации по проверке истинности стоимости:

Все значения, кроме перечисленных здесь, считаются True

• None
• False
• нуль любого числового типа, например, 0, 0.0, 0j.
• любая пустая последовательность, например, '', (), [].
• любое пустое отображение, например {}.
• экземпляры пользовательских классов, если класс определяет метод __bool__()или __len__(), когда этот метод возвращает целочисленный ноль или значение bool False.

Как можно видеть, пустой список []является ложным , поэтому наиболее эффективным представляется то , что будет сделано с логическим значением:

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

Вот несколько способов проверить, если список пуст:

a = [] #the list

1) Довольно простой питонический способ:

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

В Python пустые контейнеры, такие как списки, кортежи, наборы, запросы, переменные и т. Д., Отображаются как False. Можно просто рассматривать список как предикат ( возвращая логическое значение ). И Trueзначение будет указывать, что оно не пустое.

2) Очень явный способ: использовать, len()чтобы найти длину и проверить, равна ли она 0:

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

3) Или сравнивая его с анонимным пустым списком:

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

4) Еще один глупый способ - использовать exceptionи iter():

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

Я предпочитаю следующее:

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

Способ 1 (предпочтительный):

if not a : 
   print ("Empty") 

Способ 2:

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

Способ 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])

Иногда полезно проверять Noneпустоту отдельно, поскольку это два разных состояния. Код выше производит следующий вывод:

list is None 
list is empty 
list has 3 elements

Хотя это ничего не стоит, что Noneложно. Так что, если вы не хотите отделить тест на None-несение, вам не нужно этого делать.

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

производит ожидаемый

list is empty
list is empty
list has 3 elements

Было дано много ответов, и многие из них довольно хороши. Я просто хотел добавить, что проверка

not a

Также будут проходить Noneи другие типы пустых структур. Если вы действительно хотите проверить пустой список, вы можете сделать это:

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

мы могли бы использовать простой, если еще:

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

Если вы хотите проверить, пуст ли список:

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

Если вы хотите проверить, все ли значения в списке пусты. Однако это будет Trueдля пустого списка:

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

Если вы хотите использовать оба случая вместе:

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

Теперь вы можете использовать:

if empty_list(lst):
    # do your stuff.

Вдохновленный решением @ dubiousjim, я предлагаю использовать дополнительную общую проверку того, является ли это чем-то итеративным

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

Примечание: строка считается повторяемой. - Добавитьand not isinstance(a,(str,unicode)) если вы хотите, чтобы пустая строка была исключена

Тестовое задание:

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

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

немного более практично:

a.pop() if a else None

и самая короткая версия:

if a: a.pop() 

Начиная с python3 вы можете использовать

a == []

проверить, если список пуст

РЕДАКТИРОВАТЬ: Это работает с python2.7 тоже ..

Я не уверен, почему есть так много сложных ответов. Это довольно ясно и просто

Вы даже можете попробовать использовать bool (), как это

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

Я люблю этот способ проверки списка пуст или нет.

Очень удобно и полезно.

Просто используйте is_empty () или сделайте функцию вроде: -

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

Он может использоваться для любой структуры данных, такой как список, кортежи, словарь и многое другое. Этим вы можете назвать это много раз, используя только is_empty(any_structure).

Простой способ проверки длины равен нулю.

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

Истинное значение пустого списка Falseтаково, что для непустого списка это так True.

Что привело меня сюда, так это особый вариант использования: я на самом деле хотел, чтобы функция сообщала мне, пустой список или нет. Я хотел избежать написания своей собственной функции или использования лямбда-выражения здесь (потому что казалось, что это должно быть достаточно просто):

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

И, конечно же, есть очень естественный способ сделать это:

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

Конечно, не используйте boolв if(то есть if bool(L):), потому что это подразумевается. Но для случаев, когда «не пусто» явно требуется как функция, boolэто лучший выбор.

Чтобы проверить, является ли список пустым или нет, вы можете использовать два следующих способа. Но помните, мы должны избегать способа явной проверки типа последовательности (это less pythonicспособ):

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

Второй способ more pythonicодин. Этот метод является неявным способом проверки и гораздо более предпочтителен, чем предыдущий.

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"

Надеюсь это поможет.