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

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

a = []

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

2832
is-empty list python

27 ответов

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

использование неявной логичности пустого списка довольно питоническое.

4045

питонический способ сделать это из руководство по стилю PEP 8 (где да означает "рекомендовано" и нет означает "не рекомендуется"):

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

Yes: if not seq:
     if seq:

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

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

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

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

539

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

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

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

"питонический" способ не работает: Часть 1

путь "pythonic" терпит неудачу с массивами 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, ...), the 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 дает чтобы убедиться, что правильный тест используется для каждого типа. Не очень "питонический", но оказывается, что numpy намеренно нарушил питонизм, по крайней мере, в этом смысле.

Если вам нужно сделать больше, чем просто проверить, пуст ли вход, и вы используете другие функции numpy, такие как индексирование или математические операции, это, вероятно, более эффективно (и, конечно, более распространено), чтобы заставить вход на a массив numpy. Есть несколько приятных функций для этого быстро-самое главное numpy.asarray. Это принимает ваш ввод, ничего не делает, если это уже массив, или обертывает ваш ввод в массив, если это список, кортеж и т. д., и необязательно преобразует его в выбранный dtype. Поэтому это очень быстро, когда это может быть, и это гарантирует, что вы просто предположите, что вход является массивом numpy. Мы обычно даже просто используем одно и то же имя, так как преобразование в массив не вернет его вне течения область:

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

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

217

пустой список сам по себе считается ложным в true value testing (см. документация python):

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

@Daren Thomas

EDIT: еще один пункт против тестирования пустой список как False: как насчет полиморфизм? Вы не должны зависеть от список есть список. Он должен просто крякай, как утка - как дела? чтобы получить duckCollection крякать "Ложь", когда в ней нет элементов?

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

110

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

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

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.

но мы считаем, что это ООН-подходящие для Python, потому что Python поддерживает эту семантику непосредственно в интерфейсе списка объектов с помощью булевых принуждение.

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

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

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

и документация datamodel:

object.__bool__(self)

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

и

object.__len__(self)

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

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

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 затенен.

тогда он должен вызвать функцию, load 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 добавляет

92

ответ Патрика (принят) правильно: 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: вводит в заблуждение читателя. Вы сигнализируете о чем-то столь же важном, когда это не так. (Вы также можете сделать код менее гибким, или медленнее, или что угодно, но это все менее важно.) А если ты обычно ввести читателя в заблуждение, как это, тогда, когда вы do нужно сделать различие, это пройдет незамеченным, потому что вы были "Плачущий Волк" на всем протяжении вашего кода.

82

Я видел ниже, как предпочтительно:

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

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

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

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

a = []

for item in a:
    <do something with item>

<rest of code>

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

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

54

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

на JavaScript аналогичное понятие истина/ложь.

47

Я написал:

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 - значение типа вы готовы работать, или если вы уверены, что типа ты не подготовленные к обработке будут вызывать ошибки (например, a TypeError если вы называете len на значение, для которого оно не определено), которое вы готовы обработать. В общем, "весть" конвенций, кажется, идут это последний способ. Сожмите его, как утку, и дайте ему поднять утку, если он не знает, как крякать. Вы все еще должны думаю о том, какие предположения типа Вы делаете, и действительно ли случаи, которые вы не готовы обрабатывать должным образом, будут ошибаться в нужное место. Массивы Numpy являются хорошим примером, когда просто слепо полагаются на len или boolean typecast может не делать именно то, что вы ожидаете.

29

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

a = []

.
.
.

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

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

25

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

if not a:
    print "list is empty"


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

С документация на тестировании значения истины:

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

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

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

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

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

a = [] #the list

1) довольно простой для Python образом:

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

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

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

читаемый, и вам не нужно беспокоиться о вызове функции, такой как len() для перебора переменных. Хотя я не совсем уверен, что такое обозначение BigO чего-то подобного... но Python настолько невероятно быстр, что я сомневаюсь, что это имеет значение, если a гигантская.

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

еще один простой способ может быть

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

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

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

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

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

1

будучи вдохновленным решением @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
1

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

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

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

1

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

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

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

0

неофициальный подход :

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

посмотрите на следующий код, выполненный на интерактивном терминале Python.

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

Я думаю, что человек предложил

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

или len вы можете считать по

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

вы можете использовать еще один способ 

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

размер пустого списка всегда равен 40.

-3

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

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