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

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

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

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

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

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

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

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

Но, по крайней мере, приведенный выше случай говорит вам, что это не удалось. Если у вас есть массив с ровно одним элементом, оператор 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 , правильный метод во всех случаях, когда вы знаете, что у вас есть пустой массив, это использовать 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, пустой массив или что-то еще, вы можете объединить этот подход с помощью ответа @dubiousjim , чтобы убедиться, что для каждого типа используется правильный тест. Не очень "питонический", но оказывается, что numpy преднамеренно сломал питоничность по крайней мере в этом смысле.

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

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

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

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

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

@ Дарен Томас

  

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

В вашей коллекции утилит должно быть __nonzero__ или __len__ так что if a: будет работать без проблем.

  

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

     

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

a = []

     

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

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

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

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

Обращение к власти

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

Мне очень понравилось исследовать это, и я трачу много времени, отрабатывая свои ответы. Если вы считаете, что я что-то пропускаю, сообщите мне об этом в комментарии.

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

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

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

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

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

a = []

for item in a:
    <do something with item>

<rest of code>

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

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

Питон очень единообразен в отношении пустоты. Учитывая следующее:

a = []

.
.
.

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

Вы просто проверяете список a с помощью оператора if, чтобы убедиться, что он пуст. Из того, что я прочитал и чему научил, это «Pythonic» способ проверить, пуст ли список или кортеж.

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

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

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

Как видно, пустой список [] - это falsy , так что делать то, что будет сделано с логическое значение звучит наиболее эффективно:

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

Некоторые методы, которые я использую:

if not a:
    print "list is empty"


if len(a) == 0:
    print "list 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."

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

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

a == []

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

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

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

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

not a

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

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

Вы можете проверить, равна ли длина массива нулю (или нет). Если длина массива равна нулю , то он пуст . попробуйте следующее:

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

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

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

Мне нравится этот способ проверки, список пуст или нет.

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

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

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

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

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

a.pop() if a else None

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

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

Просто используйте 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).

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

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

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

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.

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