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

python list

2150089 просмотра

30 ответа

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

a = []

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

Автор: Ray Vega Источник Размещён: 17.05.2019 02:34

Ответы (30)


4516 плюса

Решение
if not a:
  print("List is empty")

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

Автор: Patrick Размещён: 10.09.2008 06:28

993 плюса

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

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

<b>Yes:</b> if not seq:
     if seq:

<b>No:</b>  if len(seq):
     if not len(seq):
Автор: Harley Holcombe Размещён: 10.09.2008 10:33

615 плюса

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

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

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

Автор: Jabba Размещён: 05.09.2011 12:30

248 плюса

Другие люди, кажется, обобщают этот вопрос за пределы списков, поэтому я решил добавить предостережение для другого типа последовательности, которую многие люди могли бы использовать, тем более что это первый хит в Google для «пустого массива тестов Python» ,

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

Вы должны быть осторожны с массивами 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

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

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

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

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

Автор: Mike Размещён: 21.02.2012 04:48

123 плюса

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

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

@ Дарен Томас

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

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

Автор: Peter Hoffmann Размещён: 10.09.2008 06:31

122 плюса

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

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

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

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

Автор: Aaron Hall Размещён: 20.08.2017 03:50

89 плюса

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

Автор: abarnert Размещён: 03.12.2014 02:21

70 плюса

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

if not a:
    print("The list is empty or null")
Автор: hazzen Размещён: 10.09.2008 06:28

60 плюса

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

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

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

a = []

for item in a:
    <do something with item>

<rest of code>

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

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

Автор: MrWonderful Размещён: 06.10.2015 07:25

57 плюса

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

У JavaScript есть похожее понятие истина / ложь .

Автор: George V. Reilly Размещён: 15.09.2008 05:50

33 плюса

Я написал:

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

Автор: dubiousjim Размещён: 31.05.2012 02:35

29 плюса

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

a = []

.
.
.

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

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

Автор: octopusgrabbus Размещён: 02.06.2012 03:40

26 плюса

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

if not a:
    print "list is empty"


if len(a) == 0:
    print "list is empty"
Автор: Hackaholic Размещён: 27.10.2014 12:35

25 плюса

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

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

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

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

if not a:
    print('"a" is empty!')
Автор: Sнаđошƒаӽ Размещён: 01.01.2016 06:18

19 плюса

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

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")
Автор: Inconnu Размещён: 28.11.2016 02:18

12 плюса

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

if a == []:
   print "The list is empty."
Автор: verix Размещён: 10.09.2008 06:43

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
Автор: Tagar Размещён: 13.04.2016 09:55

6 плюса

Способ 1 (предпочтительный):

if not a : 
   print ("Empty") 

Способ 2:

if len(a) == 0 :
   print( "Empty" )

Способ 3:

if a == [] :
  print ("Empty")
Автор: Vikrant Размещён: 09.02.2019 11:59

3 плюса

Другой простой способ может быть

a = []
if len(a) == 0:
  print("Empty")
else:
  print(" Not empty")
Автор: Devendra Bhat Размещён: 19.03.2018 11:14

3 плюса

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

not a

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

if isinstance(a, list) and len(a)==0:
    print("Received an empty list")
Автор: HackerBoss Размещён: 12.10.2018 04:01

3 плюса

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

a == []

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

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

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

Автор: Dheeraj M Pai Размещён: 06.11.2018 09:55

3 плюса

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

a = []
if len(a)==0 : print "List is empty"
Автор: Siddharth Satpathy Размещён: 14.11.2018 07:02

3 плюса

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

list=[]
if len(list)==0:
    print ("list is empty")
else:
    print ("list is not empty")
Автор: l. zhang Размещён: 06.01.2019 07:15

2 плюса

Будучи вдохновленным решением @ 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
Автор: AndreyS Scherbakov Размещён: 29.03.2017 02:58

1 плюс

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

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

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

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

Автор: Sunil Lulla Размещён: 13.09.2016 11:53

1 плюс

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

if len(a) == 0:
    print("a is empty")
Автор: Ashiq Imran Размещён: 12.10.2018 02:59

1 плюс

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

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

a.pop() if a else None
Автор: Andrey Suglobov Размещён: 03.11.2018 02:23

1 плюс

Проверьте, len(list) == 0возвращает ли:True

Автор: Leevo Размещён: 31.01.2019 10:41

0 плюса

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

Автор: Vineet Jain Размещён: 26.08.2017 07:04

0 плюса

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

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.
Автор: Rahul Размещён: 05.03.2018 11:30
Вопросы из категории :
32x32