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

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

 a = []
 

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

вопрос задан 10.09.2008
Ray Vega
76069 репутация

27 ответов


  • 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, с репутацией 857, 26.08.2017
  • 0 рейтинг

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

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

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

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

     if not a:
        print('"a" is empty!')
     
    ответ дан Sнаđошƒаӽ, с репутацией 6785, 1.01.2016
  • 0 рейтинг
     if not a:
      print("List is empty")
     

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

    ответ дан Patrick, с репутацией 55430, 10.09.2008
  • 0 рейтинг

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

     if not a:
        print("The list is empty or null")
     
    ответ дан hazzen, с репутацией 11805, 10.09.2008
  • 0 рейтинг

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

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

    @ Daren Thomas

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

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

    ответ дан Peter Hoffmann, с репутацией 32845, 10.09.2008
  • 0 рейтинг

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

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

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

    ответ дан verix, с репутацией 759, 10.09.2008
  • 0 рейтинг

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

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

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

    ответ дан octopusgrabbus, с репутацией 6447, 2.06.2012
  • 0 рейтинг

    Посмотрите на следующий код, выполненный на интерактивном терминале 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
    >>> 
     
    ответ дан hygull, с репутацией 2376, 27.12.2017
  • 0 рейтинг

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

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

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

    ответ дан Jabba, с репутацией 9400, 5.09.2011
  • 0 рейтинг

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

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

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

    Поэтому вместо этого:

     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 . Это используется только для объектов, которые имеют некоторое понятие длины. Этот тип не часто появляется в API Python /C. Он соответствует полям, определяемым расширением макроса 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, с репутацией 153756, 20.08.2017
  • 0 рейтинг

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

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

    Мне это нравится, потому что контрольный список пуст или нет.

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

    ответ дан Sunil Lulla, с репутацией 412, 13.09.2016
  • 0 рейтинг

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

    ответ дан abarnert, с репутацией 243425, 3.12.2014
  • 0 рейтинг

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

     a = [] #the list
     

    1) Довольно простой pythonic путь:

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

    В Python пустые контейнеры, такие как списки, кортежи, наборы, dicts, переменные и т. Д., Рассматриваются как 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, с репутацией 3347, 28.11.2016
  • 0 рейтинг

    Вы можете просто сделать:

     lst = []
    any(lst)   ##this returns False
     
    ответ дан thomas.mac, с репутацией 307, 6.07.2018
  • 0 рейтинг

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

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

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

     a = []
    
    for item in a:
        <do something with item>
    
    <rest of code>
     

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

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

    ответ дан MrWonderful, с репутацией 1673, 6.10.2015
  • 0 рейтинг

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

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

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

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

    «Pythonic» способ терпит неудачу с массивами 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

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

    Неожиданно

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

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

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

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

    ответ дан Mike, с репутацией 8913, 21.02.2012
  • 0 рейтинг

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

     if not a:
        print "list is empty"
    
    
    if len(a) == 0:
        print "list is empty"
     
    ответ дан Hackaholic, с репутацией 11929, 27.10.2014
  • 0 рейтинг

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

      a = []
     try:
      print(a[-1])
     except IndexError:
      print("List is empty")
     
    ответ дан BoRRis, с репутацией 404, 9.12.2017
  • 0 рейтинг

    я думаю, люди предложили

     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.

    ответ дан Chetan Jain, с репутацией 21, 14.12.2017
  • 0 рейтинг

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

     a = []
    if len(a) == 0:
      print("Empty")
    else:
      print(" Not empty")
     
    ответ дан Devendra Bhat, с репутацией 408, 19.03.2018
  • 0 рейтинг

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

    JavaScript имеет аналогичное понятие правды /ложности .

    ответ дан George V. Reilly, с репутацией 10693, 15.09.2008
  • 0 рейтинг

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

     l = []
    if l:
        # do your stuff.
     

    Если вы хотите проверить погоду, все значения в списке пустые.

     l = ["", False, 0, '', [], {}, ()]
    if all(bool(x) for x in l):
        # do your stuff.
     

    Однако это будет True для пустого списка.

     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, с репутацией 4159, 5.03.2018
  • 0 рейтинг

    Будучи вдохновленным решением @ 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, с репутацией 1972, 29.03.2017
  • 0 рейтинг

    Я написал:

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

    ответ дан dubiousjim, с репутацией 3809, 31.05.2012
  • 0 рейтинг

    Значение истины для пустого списка равно False а для непустого списка - True .

    ответ дан MiloMinderbinder, с репутацией 445, 16.05.2018
  • 0 рейтинг

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

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

     Yes: if not seq:
         if seq:
    
    No:  if len(seq):
         if not len(seq):
     
    ответ дан Harley Holcombe, с репутацией 105065, 10.09.2008
  • 0 рейтинг
     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 -ness, вам не нужно это делать.

     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, с репутацией 4159, 13.04.2016