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

Содержание

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

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

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

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:

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')

делать то, что 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 и документации

PyVarObject

это PyObject добавляет

Объявить пустой список в Python

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

Однако, вы когда-нибудь задумывались о том, как объявить пустой список в Python? Это может быть достигнуто двумя способами, то есть с помощью square brackets[] или с помощью конструктора list() .

Использование квадратных скобок []
Списки в Python можно создать, просто поместив последовательность в квадратные скобки [] . Чтобы объявить пустой список, просто назначьте переменную в квадратных скобках.

Пример:

  

a = []         

  

print("Values of a:", a)

print("Type of a:", type(a))

print

("Size of a:", len(a))     

Выход:

Values of a: []
Type of a: <class 'list'>
Size of a: 0

Использование конструктора list ()
Конструктор list() используется для создания списка в Python.

Syntax: list([iterable])

Parameters:
iterable: This is an optional argument that can be a sequence(string, tuple) or collection(dictionary, set) or an iterator object.

Return Type:

  • Returns an empty list if no parameters are passed.
  • If a parameter is passed then it returns a list of elements in the iterable.

Пример:

  

  

a = list()  

  

print("Values of a:", a)

print("Type of a:", type(a))

print("Size of a:", len(a))     

Выход:

Values of a: []
Type of a: <class 'list'>
Size of a: 0

Рекомендуемые посты:

Объявить пустой список в Python

0.00 (0%) 0 votes

Python | Проверьте, является ли список пустым или нет

Существуют различные способы проверки списка в Python, но все они не подходят или не соответствуют Python, «pythonic», для реализации.

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

    def Enquiry(lis1):

        if len(lis1) == 0:

            return 0

        else:

            return 1

              

    lis1 = []

    if Enquiry(lis1):

        print ("The list is not empty")

    else:

        print("Empty List")

    Выход:

    Empty List
    
  2. Теперь давайте посмотрим на более питонический способ проверки пустого списка. Этот метод проверки является неявным способом проверки и более предпочтителен, чем предыдущий.
    Пример:

    def Enquiry(lis1):

        if not lis1:

            return 1

        else:

            return 0

              

    lis1 = []

    if Enquiry(lis1):

        print (

    "The list is Empty")

    else:

        print ("The list is not empty")

    Выход:

    The list is Empty

Numpythonic путь

  1. Предыдущие методы, которые мы использовали в обычном Python, не работают по-цифровому . Другие методы, которые отлично работают для списков или других стандартных контейнеров, не работают для пустых массивов . Этот способ завершается неудачно с массивами numpy, потому что numpy пытается привести массив к массиву bools, и если он пытается оценить все эти bools одновременно для некоторого совокупного значения истинности, он завершается неудачей, поэтому мы получаем ValueError.
    Пример 1:

    import numpy

    def Enquiry(lis1):

        return(numpy.array(lis1))

          

    lis1 = [0, 1]

    if Enquiry(lis1):

        print("Not Empty")

    else:

        print("Empty")

    Выход:

    None

    Ошибка:

    Traceback (most recent call last):
      File "/home/2d237324bb5211d7216c521441a750e9.py", line 7, in 
        if Enquiry(lis1):
    ValueError: The truth value of an array with more than 
    one element is ambiguous. Use a.any() or a.all()
  2. В следующем примере мы увидим, что даже если список не пуст, вывод будет пустым. Если список содержит один 0, тогда оператор if будет некорректно получен.
    Пример 2:

    import numpy

    def Enquiry(lis1):

        return(numpy.array(lis1))

          

    lis1 = [0, ]

    if Enquiry(lis1):

        print("Not Empty")

    else:

        print("Empty")

    Выход:

    Empty
  3. Заставить работать Numpythonic

    1. Если у нас есть пустой массив, то правильный метод во всех случаях — использовать if .size . Этот размер проверяет размер массивов и возвращает True или False соответственно.
      Пример:

      import numpy

      def Enquiry(lis1):

          return(numpy.array(lis1))

            

      lis1 = []

      if Enquiry(lis1).size:

          print("Not Empty")

      else:

          print("Empty")

      Выход:

      Empty
    2. Пример 2:
      В этом примере показан другой случай с одним элементом 0, который не удался в предыдущих случаях.

      import numpy

      def Enquiry(lis1):

          return(numpy.array(lis1))

            

      lis1 = [0, ]

      if Enquiry(lis1).size:

          print("Not Empty")

      else:

          print("Empty")

      Выход:

      Not Empty

    Для получения дополнительной информации посетите руководство по стилю PEP8 .

    Рекомендуемые посты:

Python | Проверьте, является ли список пустым или нет

0.00 (0%) 0 votes

список и кортеж / Хабр

В Python, есть два похожих типа — список (list) и кортеж (tuple). Самая известная разница между ними состоит в том, что кортежи неизменяемы.

Вы не можете изменить объекты в tuple:

>>> a = (1,2,3)
>>> a[0] = 10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Но вы можете модифицировать изменяемые объекты внутри кортежа:
>>> b = (1,[1,2,3],3)
>>> b[1]
[1, 2, 3]
>>> b[1].append(4)
>>> b
(1, [1, 2, 3, 4], 3)

Внутри CPython (стандартного интерпретатора), список и кортеж реализованы как лист из указателей (ссылок) на Python объекты, т.е. физически они не хранят объекты рядом с друг другом. Когда вы удаляете объект из списка происходит удаление ссылки на этот объект. Если на объект ещё кто-то ссылается, то он продолжит находиться в памяти.
Кортежи

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

Вы можете не замечать, но вы используете кортежи когда:

  • работаете с аргументами или параметрами (они хранятся как кортежи)
  • возвращаете две или более переменных из функции
  • итерируете ключи-значения в словаре
  • используете форматирование строк

Как правило, самый просто скрипт использует тысячи кортежей:
>>> import gc
>>> def type_stats(type_obj):
...     count = 0
...     for obj in gc.get_objects():
...         if type(obj) == type_obj:
...             count += 1
...     return count
...
>>> type_stats(tuple)
3136
>>> type_stats(list)
659
>>> import pandas
>>> type_stats(tuple)
6953
>>> type_stats(list)
2455

Пустые списки vs пустые кортежи

Пустой кортеж работает как синглтон, т.е. в памяти запущенного Python скрипта всегда находится только один пустой кортеж. Все пустые кортежи просто ссылаются на один и тот же объект, это возможно благодаря тому, что кортежи неизменяемы. Такой подход сохраняет много памяти и ускоряет процесс работы с пустыми кортежами.
>>> a = ()
>>> b = ()
>>> a is b
True
>>> id(a)
4409020488
>>> id(b)
4409020488
>>> # В CPython, функция id возвращает адрес в памяти.

Но это не работает со списками, ведь они могут быть изменены:
>>> a = []
>>> b = []
>>> a is b
False
>>> id(a)
4465566920
>>> id(b)
4465370632

Оптимизация выделения памяти для кортежей

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

Этот список разделен на 20 групп, где каждая группа представляет из себя список кортежей размера n, где n от 0 до 20. Каждая группа может хранить до 2 000 свободных кортежей. Первая группа хранит только один элемент и представляет из себя список из одного пустого кортежа.

>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104

В примере выше, мы можем видеть, что a и b имеют одинаковый адрес в памяти. Это происходит из-за того, что мы мгновенно заняли свободный кортеж такого же размера.
Оптимизация выделения памяти для списков

Так как списки могут изменяться, такую же оптимизацию как в случае с кортежами провернуть уже не получится. Несмотря на это, для списков используется похожая оптимизация нацеленная на пустые списки. Если пустой список удаляется, то он так же может быть переиспользован в дальнейшем.
>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792

Изменение размера списка

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

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

Паттерн роста размера списка выглядит примерно так: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88,…

Для примера, если вы хотите добавить новый элемент в список с 8 элементами, то свободных ячеек в нём уже не будет и Python сразу расширит его размер до 16 ячеек, где 9 из них будут заняты и видны пользователю.

Формула выбора размера написанная на Python:

>>> def get_new_size(n_items):
...     new_size = n_items + (n_items // 2 ** 3)
...     if n_items < 9:
...             new_size += 3
...     else:
...             new_size += 6
...
...     return new_size
...
>>> get_new_size(9)
16

Скорость

Если сравнивать эти два типа по скорости, то в среднем по больнице, кортежи слегка быстрее списков. У Raymond Hettinger есть отличное объяснение разницы в скорости на stackoverflow.

P.S.: Я являюсь автором этой статьи, можете задавать любые вопросы.

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

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

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

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

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

Python — работа со списками. Создание списков

Список в Python — это упорядоченный изменяемый набор объектов произвольных типов. В Python отсутствует понятие массива, присущее другим языкам программирования. Список целиком и полностью справляется с этой ролью. Если массив содержит однотипные элементы, то список может содержать элементы разных типов. Почитать о том, что такое список вы можете на множестве сайтов. Данная статья посвящена основным способам создания списков. Информация будет полезна  начинающим изучать Python.

Создание пустого списка

mas = [] // создание пустого списка

Создание списка, заполненного вручную

mas = [2, -3, 'hello', 56.5] 

Также,  список можно заполнить вручную с помощью цикла, метода append и команды input

mas = []
for i in range(20): //ввод 20 элементов в цикле
    mas.append(int(input())) // добавление целого числа, введенного с клавиатуры, в конец списка

Данная программа позволяет заполнить список введенными с клавиатуры 20-ю целыми числами. Прежде чем заполнять список, он должен быть создан.

Создание списка случайных чисел

import random //подключение модуля случайных чисел random
mas=[] // объявление пустого списка
for i in range(10):
    mas.append(random.randint(0, 100)) //заполнение списка 10-ю случайными числами в диапазоне от 0 до 100
print(mas) // вывод списка

Метод randint(0, 100) генерирует случайное целое число в диапазоне от 0 до 100.

Повторюсь — чтобы добавлять в список элементы с помощью метода append он (список) должен быть создан.

Создание списка случайных чисел с помощью генератора списка

import random
mas = [random.randint(0, 100) for i in range(10)]

Ну вот мы и рассмотрели основные способы создания списка в Python

НУМЕРАЦИЯ ЭЛЕМЕНТОВ СПИСКА НАЧИНАЕТСЯ С НУЛЯ

mas = [3, 5, 7, -2]

3 — имеет индекс 0
5 — имеет индекс 1
7 — имеет индекс 2
-2 — имеет индекс 3

Изменение элементов списка

Список, как мы уже сказали, изменяемый упорядоченный набор. Значение элементов списка мы можем заменить. Например:

mas = [3, 5, 7, -2]
mas[1] = 100
mas[3] = 200

Мы получили новый список [3, 100, 7, 200]. Элементы с индексами 1 и 3 изменили свои значения.

Если я для данного списка добавлю следующую строчку кода:

mas[4] = 2323

получу сообщение об ошибке «IndexError: list assignment index out of range»  т.к. элемента с индексом 4 не существует в списке и Python не может заменить несуществующий элемент на число 2323.


В следующей статье о списках мы рассмотрим основные задачи, связанные с данной структурой данных:

  • Поиск заданного элемента в массиве (списке)
  • Поиск максимального (минимального) элемента в массиве (списке) —  не использую методы списка max и min
  • Выборка элементов массива (списка) по критерию
  • Реверс массива (списка) — не используя метод списка reverse

на Ваш сайт.

Как проверить, что список пуст? — python

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

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

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 поддерживает эти семантики непосредственно в интерфейсе объекта list с помощью логического принуждения.

Из документов (и обратите особое внимание на включение пустого списка, [] ):

По умолчанию объект считается истинным, если его класс не определяет либо метод __bool__() , который возвращает False , либо метод __len__() это возвращает ноль, когда вызывается с объектом. Здесь большинство встроенных объектов считаются ложными:

  • константы, определенные как ложные: 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')

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

Окупается ли это? (Обратите внимание, что меньше времени для выполнения эквивалентной операции лучше:)

>>> 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

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

Проверить, пуст ли список или список списков — thispointer.com

В этой статье мы обсудим четыре различных способа проверить, пуст список или нет. Затем мы также увидим, как проверить, является ли список списков пустым или нет, используя цикл for, понимание списка и функцию all ().

Проверьте, пуст ли список, используя оператор «not» в Python

В python объект последовательности может быть неявно преобразован в bool. Если последовательность пуста, она оценивается как False, иначе она оценивается как True.Итак, мы можем применить оператор if к объекту последовательности, чтобы проверить, пуст он или нет.

Применение оператора if к объекту списка

Когда «оператор if» применяется к списку, он принимает значение False, если список пуст, иначе он принимает значение True. Если мы применяем оператор not вместе с оператором if к объекту списка, он оценивает значение True, если список пуст, иначе возвращает False.

Давайте посмотрим на пример, в котором мы применяем «if condition» и «not operator», чтобы проверить, пуст список или нет,

 # Создать пустой список
list_of_num = []

# Пустой объект списка будет оцениваться как False
если не list_of_num:
    print ('Список пуст')
еще:
    print ('Список не пуст')
 

Вывод:
 Список пуст 

Проверить, пуст ли список с помощью функции len ()

Python предоставляет встроенную функцию len (),

 len (последовательность) 

Он принимает последовательность, такую ​​как список, кортеж или набор и т.д., и возвращает количество элементов в этой последовательности i.е. размер последовательности.
Итак, мы можем проверить размер списка, передав объект списка в функцию len (). Как только у нас есть размер списка, мы можем подтвердить, пуст ли список, проверив, равен ли его размер 0.

Например,

 # Создать пустой список
list_of_num = []

# Проверяем, равен ли размер списка 0
если len (list_of_num) == 0:
    print ('Список пуст')
еще:
    print ('Список не пуст')
 

Вывод:
 Список пуст 

Проверьте, пуст ли список, используя __len __ ()

Класс

List имеет специальный перегруженный метод

 list.__len __ () 

Возвращает количество элементов в списке.
Мы можем проверить размер списка, вызвав функцию __len __ () для объекта списка. Когда у нас есть размер списка, мы можем подтвердить, пуст ли список, проверив, равен ли его размер 0.

Например,

 # Создать пустой список
list_of_num = []

# Проверяем, равен ли размер списка 0
если list_of_num .__ len __ () == 0:
    print ('Список пуст')
еще:
    print ('Список не пуст')
 

Вывод:
 Список пуст 

Проверьте, пуст ли список, сравнив с []

В Python пустые квадратные скобки [] указывают на пустой список.Итак, мы можем проверить, является ли наш объект списка пустым или нет, просто сравнив его с [], т.е.

 # Создать пустой список
list_of_num = []

# Проверяем, указывает ли объект списка на литерал []
если list_of_num == []:
    print ('Список пуст')
еще:
    print ('Список не пуст')
 

Вывод:
 Список пуст 

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

Могут быть сценарии, когда у нас есть список списков, и мы хотим узнать, все ли подсписки пусты.Есть разные способы сделать это. Давайте обсудим их по очереди.

Проверить, пуст ли список списков с помощью цикла

Предположим, у нас есть список списков,

 # Список списков
list_of_lists = [[], [], [], []]
 

Мы создали функцию, которая принимает список списков и проверяет, все ли подсписки в данном списке пусты,
 def check_if_empty (list_of_lists):
    для элемента в list_of_lists:
        если элемент:
            return False
    вернуть True
 

Эта функция принимает список списков, затем перебирает все подсписки в основном списке, используя цикл for, и для каждого подсписка проверяет, является ли он пустым или нет, используя «если условие» и «не оператор».Если какой-либо из подсписок не пуст, он возвращает False, где, как если бы все подсписки пусты, он возвращает True.

Давайте посмотрим, как использовать эту функцию, чтобы проверить, является ли список списков пустым или нет

 if check_if_empty (list_of_lists):
    print ('Список списков пуст')
еще:
    print ('Список списков не пуст')
 

Выход:
 Список списков пуст 

Проверить, пуст ли список списков, используя понимание списка

В отличие от предыдущего решения, здесь мы проверим, все ли подсписки в данном списке пусты или нет, в одном, например, с помощью функции «Понимание списка» и функции all ().

 def check_if_empty_2 (list_of_lists):
    вернуть все ([не элемент для элемента в list_of_lists])

list_of_lists = [[], [], [], []]

если check_if_empty_2 (list_of_lists):
    print ('Список списков пуст')
еще:
    print ('Список списков не пуст') 

Выход:
 Список списков пуст 

Понимание списка вернуло список типа bool, где каждая запись в этом логическом списке представляет подсписок из основного списка. Если подсписок был пуст, то соответствующая запись в этом списке bool будет True, иначе False.Затем мы передали этот список bool в функцию all (), чтобы проверить, все ли элементы в этом списке имеют значение True или нет. Если все элементы в списке bool имеют значение True, это означает, что все подсписки в основном списке пусты.

Полный пример выглядит следующим образом:

 def check_if_empty (list_of_lists):
    для элемента в list_of_lists:
        если элемент:
            return False
    вернуть True


def check_if_empty_2 (список_список):
    вернуть все ([не элемент для элемента в list_of_lists])


def main ():
    print ('*** Проверить, пуст ли список с помощью оператора "не в" ***')

    # Создаем пустой список
    list_of_num = []

    # Пустой объект списка будет оцениваться как False
    если не list_of_num:
        print ('Список пуст')
    еще:
        print ('Список не пуст')

    print ('*** Проверить, пуст ли список с помощью функции len () ***')

    # Создаем пустой список
    list_of_num = []

    # Проверяем, равен ли размер списка 0
    если len (list_of_num) == 0:
        print ('Список пуст')
    еще:
        print ('Список не пуст')

    print ('*** Проверьте, пуст ли список, используя __len __ () ***')

    # Создаем пустой список
    list_of_num = []

    # Проверяем, равен ли размер списка 0
    если list_of_num.__len __ () == 0:
        print ('Список пуст')
    еще:
        print ('Список не пуст')

    print ('*** Проверить, пуст ли список, сравнив с [] ***')

    # Создаем пустой список
    list_of_num = []

    # Проверяем, указывает ли объект списка на литерал []
    если list_of_num == []:
        print ('Список пуст')
    еще:
        print ('Список не пуст')

    print ('**** Проверить, пуст ли список списков в python ****')

    print ('*** Проверить, пуст ли список списков с помощью цикла for ***')

    # Список списка
    list_of_lists = [[], [], [], []]

    если check_if_empty (list_of_lists):
        print ('Список списков пуст')
    еще:
        print ('Список списков не пуст')

    print ('*** Проверьте, пуст ли список списков, используя понимание списка ***')

    # Список списка
    list_of_lists = [[], [], [], []]

    если check_if_empty_2 (list_of_lists):
        print ('Список списков пуст')
    еще:
        print ('Список списков не пуст')


если __name__ == '__main__':
   основной () 

Вывод:
 *** Проверить, пуст ли список, с помощью оператора «не в» ***
Список пуст
*** Проверьте, пуст ли список, используя функцию len () ***
Список пуст
*** Проверьте, пуст ли список, используя __len __ () ***
Список пуст
*** Проверьте, пуст ли список, сравнив с [] ***
Список пуст
**** Проверить, пуст ли список списков в python ****
*** Проверьте, пуст ли список списков, используя цикл for ***
Список списков пуст
*** Проверьте, является ли список списков пустым, используя понимание списка ***
Список списков пуст 
.Гибкость типов

и многое другое — The Renegade Coder

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

Короче говоря, лучший способ проверить, пуст ли список, — это воспользоваться гибкостью типов этого списка. Например, оператор if my_list вернет истину, если список не пуст. Конечно, есть и другие способы проверить, пуст ли список, например, проверить его длину и напрямую сравнить с другим пустым списком.

Если это все, что вам нужно, помогите расширить сайт, посетив мой список способов поддержки The Renegade Coder. В противном случае перейдите в раскрывающийся список ниже, чтобы получить более подробную информацию, включая сводку видео, несколько решений с подробностями, показатели производительности и даже проблему в социальных сетях (см. #RenegadePython в Twitter).

Содержание

Обзор видео

Если вам не нравится читать, вы можете посмотреть это видео на YouTube, которое охватывает в основном тот же контент.Честно говоря, вы, вероятно, сможете прочитать эту статью быстрее, но я ценю просмотры!

Если вы решите посмотреть видео, я рекомендую перейти на YouTube, где вы можете получить доступ к отметкам времени для каждого решения. Пока вы там, почему бы не поставить лайк?

Описание проблемы

До сих пор мы много играли со структурами данных, такими как списки и словари. Что касается списков, мы научились суммировать элементы двух списков и даже научились преобразовывать два списка в словарь.Однако во всех этих манипуляциях со списками мы никогда не обсуждали, как проверить, пуст ли список.

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

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

 Python 3.6.3 (v3.6.3: 2c5fed8, 3 октября 2017 г., 17:26:49) [MSC v.1900 32 бит (Intel)] на win32
Для получения дополнительной информации введите «помощь», «авторские права», «кредиты» или «лицензия».
>>> my_list = список ()
>>> my_list [0]
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
IndexError: индекс списка вне диапазона 

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

Решения

Когда дело доходит до проверки того, что список пуст в Python, есть несколько решений, например:

  • Проверка того, что длина списка равна нулю
  • Сравнение списка напрямую с другим пустым списком
  • Проверка того, что список пуст по гибкости его типа (предпочтительный метод)

Обязательно взвесьте все за и против каждого решения, прежде чем принимать ваше решение.

Проверить, пуст ли список по его длине

Хорошо, поэтому первый метод проверки того, пуст ли список, — это проверить, что длина списка равна нулю . Как человек, первым изучивший Java, я считаю это решение интуитивно понятным. Взгляните:

 my_list = список ()
если len (my_list) == 0:
    pass # список пуст 

В этом примере мы создаем список с именем my_list , который пуст. Затем мы запускаем на нем метод len () , который должен вернуть ноль.Если все пойдет хорошо, мы сравним ноль с нулем, чтобы доказать, что список пуст.

Если бы мы использовали это решение в нескольких случаях, мы бы обнаружили, что оно действительно отлично работает:

 >>> мой_лист = список ()
>>> если len (my_list) == 0:
        print ("Список пуст")
    еще:
        print ("Список не пустой")

«Список пуст»

>>> my_list = ["красный", "желтый", "зеленый"]
>>> если len (my_list) == 0:
        print ("Список пуст")
    еще:
        print ("Список не пустой")

«Список не пустой»

>>> my_list = ()
>>> если len (my_list) == 0:
        print ("Список пуст")
    еще:
        print ("Список не пустой")

«Список пуст» 

К сожалению, недостатком этого метода является то, что он не очень питоничен.В конце концов, сообщество Python очень строго относится к своим идиомам, поэтому, вероятно, стоит по возможности избегать этого метода.

Проверить, пуст ли список, путем прямого сравнения

Другое решение, упомянутое vorsprung на dev.to, состоит в том, чтобы сравнить список напрямую с пустым списком :

 my_list = список ()
если my_list == []:
    pass # список пуст 

Еще раз создаем пустой список. Затем мы сравниваем этот список напрямую с пустым списком, используя оператор == .Если все пойдет хорошо, мы сможем доказать, что my_list пуст.

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

 >>> мой_лист = список ()
>>> если my_list == []:
        print ("Список пуст")
    еще:
        print ("Список не пустой")

«Список пуст»

>>> my_list = [1, 2, 3]
>>> если my_list == []:
        print ("Список пуст")
    еще:
        print ("Список не пустой")

«Список не пустой»

>>> my_list = ()
>>> если my_list == []:
        print ("Список пуст")
    еще:
        print ("Список не пустой")

"Список не пустой" # Ух ой! 

Ясно, что это решение работает нормально, но не считается питоническим.В конце концов, в Python есть два разных типа списковых коллекций: кортежи и списки. Кортежи — это неизменяемые списки, и сравнение пустого кортежа с пустым списком () == [] вернет false.

Другими словами, если вы не знаете, с какой коллекцией имеете дело, это не лучшее решение. Вместо этого вам следует использовать следующее решение гибкости типов.

Проверить, является ли список пустым, по гибкости типа

Динамическая типизация — это забавная функция Python, поскольку она позволяет переменной принимать множество форм.В то время как кого-то со статическим опытом набора текста это может расстроить, другие сочтут, что динамическая типизация в Python имеет свои преимущества. Среди этих преимуществ — тот факт, что пустые последовательности оцениваются как ложные в соответствии со стандартом PEP 8.

Итак, что это означает с точки зрения кода? Что ж, это означает, что мы можем рассматривать список как логическое . Например:

 my_list = список ()
если не my_list:
    pass # список пуст 

В этом примере мы создаем пустой список.Затем мы проверяем, пуст ли список, проверяя, является ли это не заполненной последовательностью. В результате мы можем передать сюда любую последовательность, а не только списки, и получить ожидаемый результат.

Это может показаться не очень интуитивным, но это часть принятого стандарта PEP 8. Другими словами, это метод, который мы должны использовать в производственном коде. Всегда проверять, является ли список пустым из-за гибкости его типов .

Производительность

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

 setup = "my_list = list ()"

длина = "" "
если len (my_list) == 0:
    проходить
"" "

direct = "" "
если my_list == []:
    проходить
"" "

flex = "" "
если не my_list:
    проходить
"" "

С этими строками мы можем использовать библиотеку timeit следующим образом:

 >>> время импорта
>>> min (timeit.repeat (stmt = length, setup = setup, repeat = 10))
0,06464349999998831
>>> min (timeit.повторить (stmt = direct, setup = setup, repeat = 10))
0,035628

000607 >>> min (timeit.repeat (stmt = flex, setup = setup, repeat = 10)) 0,016961899999955676

Здесь мы использовали функцию repeat () , чтобы запустить тест 10 раз, прежде чем вывести нижнюю границу времени выполнения. В этом случае метод прямого сравнения примерно в два раза быстрее, чем проверка длины. Тем не менее, метод гибкости типов еще быстрее.

Для полноты картины нам нужно будет запустить эти тесты в списке, который не пуст.В результате нам придется обновить переменную setup до следующего вида:

 setup = "my_list = [1, 5, 6, -4, 12, 3, 1, 1, 0]" 

Затем, если мы перезапустим наши тесты, мы сможем наблюдать любые изменения во времени выполнения:

 >>> мин (timeit.repeat (stmt = length, setup = setup, repeat = 10))
0,06420660000003409
>>> min (timeit.repeat (stmt = direct, setup = setup, repeat = 10))
0,03376020000007429
>>> min (timeit.repeat (stmt = flex, setup = setup, repeat = 10))
0.012936999999965337 

Как оказалось, время работы примерно одинаковое. Другими словами, рекомендуемая идиома гибкости типов работает лучше всего в обоих случаях. Для справки, эти тесты были выполнены с использованием Windows 10 и Python 3.7.3. Если вы хотите узнать больше о тестировании производительности в Python, ознакомьтесь с моей статьей под названием How to Performance Test Python Code.

Вызов

Как и большинство статей в этой серии, я подумал, что было бы интересно продвинуть то, что мы узнали, еще дальше.Другими словами, теперь, когда мы знаем, как проверить, пуст ли список, давайте попробуем немного расширить наши знания.

Наша сегодняшняя задача развивает идею «пустоты» немного дальше. В частности, давайте попробуем применить его к другой структуре данных: словарю. Как мы можем написать программу, которая определяет, пуст ли словарь?

Попробуйте написать небольшой код, который ведет себя примерно как следующий псевдокод:

 emptiness_detection (my_dict) # истина, если пусто 

Как всегда, если вы придумаете решение, не стесняйтесь делиться им в Твиттере, используя хэштег #RenegadePython.Если увижу, то отдам!

А пока вот мое решение:

В моей статье «Как проверить, является ли список пустым» я просил вас развить идею немного дальше и попробовать проверить словарь на пустоту. Как оказалось, решение гибкости типов все еще работает! Есть ли другие решения? Не стесняйтесь делиться, используя тег #RenegadePython. pic.twitter.com/dCh3sBpX6F

— Джереми Грифски (@ RenegadeCoder94) 19 апреля 2020 г.

Очевидно, гибкость типов все еще работает! Интересно, есть ли другие способы решения этой проблемы.

Небольшое резюме

Сегодняшняя тема — как проверить, пуст ли список в Python. Как всегда, в этом разделе мы делаем небольшой обзор решений, которыми поделились выше:

 my_list = список ()

# Проверяем, пуст ли список по своей длине
если len (my_list) == 0:
    pass # список пуст

# Проверяем, пуст ли список прямым сравнением
если my_list == []:
    pass # список пуст

# Проверяем, является ли список пустым по гибкости типа ** предпочтительный метод **
если не my_list:
    pass # список пуст 

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

В противном случае рассмотрите возможность подписки на The Renegade Coder, чтобы получать больше подобного контента прямо в свой почтовый ящик, а также ряд других преимуществ, таких как доступ к блогу. Если вам просто нужна еженедельная рассылка, оставьте свой адрес электронной почты в форме подписки.

А пока ознакомьтесь с некоторыми из этих замечательных статей о Python:

Кроме того, ознакомьтесь с некоторыми из этих книг по Python на Amazon (реклама):

Еще раз спасибо за вашу поддержку!

Навигация по сериям ← Как преобразовать два списка в словарь в Python: Zip, понимания и циклыКак скопировать список в Python: фрагменты, копирование и многое другое →.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *