Как проверить, если список пуст?
Например, если передано следующее:
a = []
Как проверить, является ли a
пустым?
22 ответа
Я предпочитаю это явно:
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)
И документация по датамоделю:
Вызывается для реализации проверки истинности и встроенной операции
bool()
; должен вернутьFalse
илиTrue
. Когда этот метод не определен,__len__()
вызывается, если он определен, и объект считается истинным, если его результат ненулевой. Если класс не определяет ни__len__()
ни__bool__()
, все его экземпляры считаются истинными.
и
Вызывается для реализации встроенной функции
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 и документации
Это расширение
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
- ноль любого числового типа, например,
0
,0.0
,0j
. - любая пустая последовательность, например,
''
,()
,[]
. - любое пустое сопоставление, например,
{}
. - экземпляры пользовательских классов, если класс определяет
__bool__()
или__len__()
, когда этот метод возвращает целочисленный ноль или логическое значениеFalse
.
None
литий>
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