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

Question

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

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

a = []

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

27 2832

python is-empty list

27 ответов:

в подходящие для Python способ сделать это с руководство по стилю 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

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

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

217

пустой список сам по себе считается ложным в тестировании истинного значения (см. документация python):
a = []
if a:
     print "not empty"
@Daren Thomas

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

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

110

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

например, если передано следующее:
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 (и обратите особое внимание на включение пустого списка,[]):

по умолчанию, объект считается истинным, если его класс определяет либо __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')
делать то, что питон обычно окупается в производительности:

окупается ли это? (Обратите внимание, что меньше времени для выполнения эквивалентной операции лучше:)
>>> 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
"Питонический" способ является гораздо проще и быстрее проверить, так как длина списка кэшируется в заголовке объекта:
>>> 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, действующий как скаляры с ложными значениями и т. д. И иногда важно быть откровенным об этом. И в таком случае, вы знаете что вы хотите быть ясно, так что вы можете проверить именно это. Например, 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
первый тест в ответ на ответ @Майк, выше. Третья строка также может быть заменена на:
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.

как видно, пустой список [] и ложь, поэтому делать то, что было бы сделано для логического значения, звучит наиболее эффективно:
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")
или лен вы можете рассчитывать на
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

Patrick · Accepted Answer · 2017-04-27 05:52:03

if not a:
  print("List is empty")
С помощью неявного booleanness пустой список вполне подходящие для Python.

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

27 ответов:

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

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

в "весть" не работает: Часть 2

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

в numpythonic способом

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

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

обращение к Власть

объяснение

делать то, что питон обычно окупается в производительности:

доказательства из источника C и документации

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

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