Как проверить, пуст ли список?
например, если передано следующее:
a = []
Как проверить, если a
пусто?
27 ответов
if not a:
print("List is empty")
использование неявной логичности пустого списка довольно питоническое.
питонический способ сделать это из руководство по стилю 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 empty array".
другие методы не работают для массивов numpy
вам нужно быть осторожным с массивами numpy, потому что другие методы, которые отлично работают для list
S или другие стандартные контейнеры не для массивов numpy. Я объясните, почему ниже, но вкратце,предпочтительный способ использовать size
.
"питонический" способ не работает: Часть 1
путь "pythonic" терпит неудачу с массивами numpy, потому что numpy пытается привести массив к массиву bool
S и if x
пытается оценить все эти bool
s сразу для какого-то совокупного значения истины. Но это не имеет никакого смысла, поэтому вы получаете 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
проверьте работу во всех случаях, которые я вижу на этой странице.
пустой список сам по себе считается ложным в true value testing (см. документация python):
a = []
if a:
print "not empty"
@Daren Thomas
EDIT: еще один пункт против тестирования пустой список как False: как насчет полиморфизм? Вы не должны зависеть от список есть список. Он должен просто крякай, как утка - как дела? чтобы получить duckCollection крякать "Ложь", когда в ней нет элементов?
ваш duckCollection должен реализовать __nonzero__
или __len__
Итак, если a: будет работать без проблем.
лучший способ проверить, если список пуст
например, если прошло следующее:
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:
привлечен к реализации истины тестирования и встроенные операции
bool()
; должен возвратитьFalse
илиTrue
. Если этот метод не определен,__len__()
называется, если он определен, и объект считается истинным, если его результат равен нулю. Если класс не определяет ни__len__()
ни__bool__()
, все его экземпляры считаются истинными.
и
вызывается для реализации встроенной функции
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 и документации
это
PyObject
добавляет
ответ Патрика (принят) правильно: 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 нужно сделать различие, это пройдет незамеченным, потому что вы были "Плачущий Волк" на всем протяжении вашего кода.
зачем вообще проверять?
никто, кажется, не обратился к вопросу вашего нужно чтобы проверить этот список в первую очередь. Поскольку вы не предоставили никакого дополнительного контекста, я могу представить, что вам, возможно, не нужно делать эту проверку в первую очередь, но вы не знакомы с обработкой списка в Python.
Я бы сказал, что наиболее подходящие для Python способ заключается в том, чтобы не проверять вообще, а просто обрабатывать список. Так он поступит правильно. пустой или полный.
a = []
for item in a:
<do something with item>
<rest of code>
Это имеет преимущество обработки любого содержимого a, пока не требующ специфической проверки для пустоты. Если 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
- значение типа вы готовы работать, или если вы уверены, что типа ты не подготовленные к обработке будут вызывать ошибки (например, a TypeError
если вы называете len
на значение, для которого оно не определено), которое вы готовы обработать. В общем, "весть" конвенций, кажется, идут это последний способ. Сожмите его, как утку, и дайте ему поднять утку, если он не знает, как крякать. Вы все еще должны думаю о том, какие предположения типа Вы делаете, и действительно ли случаи, которые вы не готовы обрабатывать должным образом, будут ошибаться в нужное место. Массивы Numpy являются хорошим примером, когда просто слепо полагаются на len
или boolean typecast может не делать именно то, что вы ожидаете.
Python очень однороден в отношении обработки пустоты. Учитывая следующее:
a = []
.
.
.
if a:
print("List is not empty.")
else:
print("List is empty.")
вы просто проверяете список a с помощью оператора "if", чтобы увидеть, пуст ли он. Из того, что я читал и чему меня учили, это "Питонический" способ увидеть, пуст ли список или кортеж.
некоторые методы, которые я использую:
if not a:
print "list is empty"
if len(a) == 0:
print "list is empty"
С документация на тестировании значения истины:
все значения, кроме перечисленных здесь, считаются True
None
False
- ноль любого числового типа, например,
0
,0.0
,0j
. - любая пустая последовательность, например,
''
,()
,[]
. - любое пустое отображение, например,
{}
. - экземпляров пользовательских классы, если класс определяет
__bool__()
или__len__()
метод, когда этот метод возвращает целое число ноль или bool значениеFalse
.
как видно, пустой список []
is ложь, поэтому то, что было бы сделано с булевым значением, звучит наиболее эффективно:
if not a:
print('"a" is empty!')
вот несколько способов проверить, пуст ли список:
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")
Я предпочитаю следующее:
if a == []:
print "The list is empty."
читаемый, и вам не нужно беспокоиться о вызове функции, такой как len()
для перебора переменных. Хотя я не совсем уверен, что такое обозначение BigO чего-то подобного... но Python настолько невероятно быстр, что я сомневаюсь, что это имеет значение, если a
гигантская.
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
вы даже можете попробовать использовать bool (), как это
a = [1,2,3];
print bool(a); # it will return True
a = [];
print bool(a); # it will return False
Мне нравится этот способ проверки списка пуст или нет.
очень удобно и полезно.
будучи вдохновленным решением @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
если вы хотите проверить, пуст ли список;
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.
просто используйте 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)
.
посмотрите на следующий код, выполненный на интерактивном терминале 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
>>>
Я думаю, что человек предложил
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.