Наприклад, якщо було передано наступне:

a = []

Як перевірити, чи aє порожнім?

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

Використання неявної буленості порожнього listє досить пітонічним.

Пітонічний спосіб зробити це з посібника зі стилю PEP 8 (де Так означає "рекомендується", а Ні - не "Не рекомендується"):

Для послідовностей (рядки, списки, кортежі) використовуйте той факт, що порожні послідовності є хибними.

Yes: if not seq:
     if seq:

No:  if len(seq):
     if not len(seq):

Я віддаю перевагу явно:

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

Таким чином, на 100% зрозуміло, що liце послідовність (список), і ми хочемо перевірити її розмір. Моя проблема if not li: ...полягає в тому, що вона створює помилкове враження, що liє булевою змінною.

_{Це перший хіт google для "python test порожнього масиву" та подібних запитів, плюс інші люди, схоже, узагальнюють питання поза просто списками, тому я подумав, що я би додав застереження для іншого типу послідовності, що багато людей може використовувати.}

Інші методи не працюють для масивів NumPy

Вам потрібно бути обережними з масивами 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

Але принаймні випадок вище говорить про те, що це не вдалося. Якщо у вас є масив 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, навіть якщо масив має нульові елементи.

Нумепітонічний спосіб

Як пояснено у FAQ щодо SciPy , правильним методом у всіх випадках, коли ви знаєте, що у вас є масив 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

Якщо ви не впевнені, чи може це бути a list, масив NumPy чи щось інше, ви можете поєднати цей підхід з відповіддю, який @dubiousjim дає, щоб переконатися, що правильний тест використовується для кожного типу. Не дуже "пітонічний", але виявляється, що NumPy навмисно зламав пітонічність принаймні в цьому сенсі.

Якщо вам потрібно зробити більше, ніж просто перевірити, чи вхід порожній, і ви використовуєте інші функції NumPy, такі як індексація чи математичні операції, можливо, це більш ефективно (і, звичайно, більш часто), щоб змусити вхід бути NumPy масивом. Існує кілька приємних функцій для цього швидко - найголовніше numpy.asarray. Це забирає ваш вхід, нічого не робить, якщо це вже масив, або завершує ваш вхід у масив, якщо це список, кортеж тощо, і необов'язково перетворює його на обраний вами dtype. Тому це дуже швидко, коли це може бути, і це гарантує вам просто припустити, що вхід є масивом NumPy. Зазвичай ми навіть просто використовуємо те саме ім'я, оскільки перетворення в масив не призведе до того, що воно не виходить за межі поточної області :

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

Це змусить x.sizeперевірити роботу у всіх випадках, які я бачу на цій сторінці.

Найкращий спосіб перевірити, чи список порожній

Наприклад, якщо було передано наступне:

a = []

Як я перевіряю, чи є порожнім?

Коротка відповідь:

Розмістіть список у бульовому контексті (наприклад, з оператором ifабо while). Він перевірить, Falseчи порожній він, Trueінакше. Наприклад:

if not a:                           # do this!
    print('a is an empty list')

PEP 8

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 підтримує цю семантику безпосередньо в інтерфейсі об'єкта списку за допомогою булевого примусу.

З документів (і відзначте включення порожнього списку []):

За замовчуванням об’єкт вважається істинним, якщо його клас не визначає або __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

Докази з джерела та документації С

PyVarObject

Це розширення, PyObjectщо додає ob_sizeполе. Це використовується лише для об'єктів, які мають певне поняття довжини. Цей тип не часто з’являється в API Python / C. Він відповідає полям, визначеним розширенням PyObject_VAR_HEADмакросу.

З джерела c у Включити / 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

Відповідь на коментарі:

Я зазначу, що це справедливо і для не порожнього випадку, хоча його досить потворно, як і l=[]тоді %timeit len(l) != 090,6 нс ± 8,3 нс, %timeit l != []55,6 нс ± 3,09, %timeit not not l38,5 нс ± 0,372. Але немає ніякого задоволення, not not lнезважаючи на потрійну швидкість. Це виглядає смішно. Але швидкість виграє,
я вважаю, що проблема тестується з часом, оскільки це просто if l:достатньо, але дивно %timeit bool(l)дає 101 нс ± 2,64 нс. Цікаво, що без цього штрафу немає способу примусити копатися. %timeit lмарно, оскільки не відбудеться перетворення.

Магія IPython %timeitтут не зовсім марна:

In [1]: l = []                                                                  

In [2]: %timeit l                                                               
20 ns ± 0.155 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

In [3]: %timeit not l                                                           
24.4 ns ± 1.58 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [4]: %timeit not not l                                                       
30.1 ns ± 2.16 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Ми бачимо, що тут є трохи лінійної вартості для кожної додаткової not. Ми хочемо бачити витрати, цетерис паррібус , тобто всі інші рівні - там, де все інше максимально зведено до мінімуму:

In [5]: %timeit if l: pass                                                      
22.6 ns ± 0.963 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [6]: %timeit if not l: pass                                                  
24.4 ns ± 0.796 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [7]: %timeit if not not l: pass                                              
23.4 ns ± 0.793 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Тепер давайте розглянемо випадок непорожнього списку:

In [8]: l = [1]                                                                 

In [9]: %timeit if l: pass                                                      
23.7 ns ± 1.06 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [10]: %timeit if not l: pass                                                 
23.6 ns ± 1.64 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [11]: %timeit if not not l: pass                                             
26.3 ns ± 1 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Що ми можемо побачити тут, це те, що мало значення, чи переходите ви до фактичної boolперевірки стану або до самого списку, і якщо що-небудь, то надання списку, як є, відбувається швидше.

Python написаний на С; вона використовує свою логіку на рівні С. Все, що ви пишете на Python, буде повільніше. І це, ймовірно, буде на порядок повільніше, якщо ви безпосередньо не використовуєте механізми, вбудовані в Python.

Сам порожній список вважається помилковим при тестуванні на справжнє значення (див. Документацію на python ):

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

@Daren Thomas

EDIT: Ще один момент проти тестування порожнього списку як False: А як щодо поліморфізму? Ви не повинні залежати від списку, який є списком. Він повинен просто хитатися, як качка - як ти збираєшся отримати свою duckCollection, щоб збивати "False", коли у неї немає елементів?

Ваш duckCollection повинен реалізувати __nonzero__або __len__так, якщо a: буде працювати без проблем.

Відповідь Патріка (прийнята) правильна: 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:оману читача. Ти сигналізуєш про щось таке важливе, коли це не так. (Ви можете також зробити код менш гнучким, або повільніше, або будь-який інший , але це все , що менш важливо.) І якщо ви постійно вводити читача в оману , як це, тоді , коли ви робите потреба зробити відмінність, це буде проходити непоміченим , тому що ви "плакали вовка" по всьому коду.

Навіщо взагалі перевіряти?

Здається, ніхто не звертався до сумнівів у вашій необхідності перевірити список. Оскільки ви не надали додаткового контексту, я можу уявити, що вам, можливо, не потрібно робити цю перевірку в першу чергу, але ви не знайомі з обробкою списку в Python.

Я б заперечував, що найбільш пітонічний спосіб - це взагалі не перевіряти, а просто обробляти список. Таким чином він зробить правильно, будь то порожній або повний.

a = []

for item in a:
    <do something with item>

<rest of code>

Це має перевагу обробки будь-якого контенту , не вимагаючи перевірки конкретної для порожнечі. Якщо порожньо, залежний блок не буде виконуватися , і інтерпретатор провалиться до наступного рядка.

Якщо вам дійсно потрібно перевірити масив на порожнечу, інших відповідей достатньо.

len()є операцією O (1) для списків, рядків, диктів та наборів Python. Python внутрішньо відстежує кількість елементів у цих контейнерах.

JavaScript має подібне поняття truthy / falesy .

Я написав:

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 або булева клавіша може не робити саме те, що ви очікуєте.

З документації щодо перевірки цінності на істинність:

Всі значення, крім зазначених тут, враховуються True

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

Як видно, порожній список []є хибним , тому те, що було б зроблено для булевого значення, звучить найбільш ефективно:

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

Ось декілька способів перевірити, чи список порожній:

a = [] #the list

1) Досить простий пітонічний спосіб:

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

У Python порожні контейнери, такі як списки, кортежі, набори, дикти, змінні тощо False. Можна просто трактувати список як предикат ( повертає булеве значення ). І Trueзначення вказувало б на те, що воно не порожнє.

2) Дуже чіткий спосіб: за допомогою len()знахідки знайти довжину і перевірити, чи вона дорівнює 0:

if len(a) == 0:
    print("a is empty")

3) Або порівнюючи його з анонімним порожнім списком:

if a == []:
    print("a is empty")

4) Інший ще дурний спосіб зробити це з допомогою exceptionі iter():

try:
    next(iter(a))
    # list has elements
except StopIteration:
    print("Error: a is empty")

Я віддаю перевагу наступному:

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

Спосіб 1 (бажаний):

if not a : 
   print ("Empty") 

Спосіб 2:

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

Спосіб 3:

if a == [] :
  print ("Empty")

def list_test (L):
    if   L is None  : print('list is None')
    elif not L      : print('list is empty')
    else: print('list has %d elements' % len(L))

list_test(None)
list_test([])
list_test([1,2,3])

Іноді добре перевірити окремо Noneі на порожнечу, оскільки це два різних стани. Код, наведений вище, дає такий вихід:

list is None 
list is empty 
list has 3 elements

Хоча це нічого не варте None. Отже, якщо ви не хочете відокремлювати тест на None-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

Дано багато відповідей, і багато з них досить непогані. Я просто хотів додати, що чек

not a

також буде передаватися для Noneінших типів порожніх структур. Якщо ви справді хочете перевірити наявність порожнього списку, ви можете зробити це:

if isinstance(a, list) and len(a)==0:
    print("Received an empty list")

ми можемо використовувати простий, якщо інше:

item_list=[]
if len(item_list) == 0:
    print("list is empty")
else:
    print("list is not empty")

Якщо ви хочете перевірити, чи список порожній:

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

Якщо ви хочете перевірити, чи всі значення в списку порожні. Однак це буде Trueдля порожнього списку:

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.

Натхненний рішенням @ 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

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

трохи практичніше:

a.pop() if a else None

і найсуворіша версія:

if a: a.pop() 

Від python3 і далі ви можете використовувати

a == []

щоб перевірити, чи список порожній

EDIT: Це також працює з python2.7.

Я не впевнений, чому так багато складних відповідей. Це досить чітко і прямо

Ви навіть можете спробувати використовувати bool (), як це

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

Мені подобається цей спосіб перевірки, чи список порожній чи ні.

Дуже зручно і корисно.

Просто використовуйте 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).

Простий спосіб перевірки довжини дорівнює нулю.

if len(a) == 0:
    print("a is empty")

Значення істинності порожнього списку становить Falseтоді, коли для не порожнього списку воно є True.

Що мене сюди привело, - це особливий випадок використання: я насправді хотів, щоб функція повідомила мені, чи список порожній чи ні. Я хотів уникнути написання власної функції або використання лямбда-виразу тут (бо здавалося, що це має бути досить просто):

foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))

І, звичайно, є дуже природний спосіб зробити це:

foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))

Звичайно, не використовуйте boolв if(тобто if bool(L):), тому що це мається на увазі. Але, у випадках, коли "не порожньо" явно потрібна функція, boolце найкращий вибір.

Щоб перевірити, чи список порожній чи ні, можна скористатися двома наступними способами. Але пам’ятайте, нам слід уникати способу явної перевірки типу послідовності (це less pythonicспосіб):

def enquiry(list1): 
    if len(list1) == 0: 
        return 0
    else: 
        return 1

# ––––––––––––––––––––––––––––––––

list1 = [] 

if enquiry(list1): 
    print ("The list isn't empty") 
else: 
    print("The list is Empty") 

# Result: "The list is Empty".

Другий спосіб - more pythonicодин. Цей метод є неявним способом перевірки і набагато кращим, ніж попередній.

def enquiry(list1): 
    if not list1: 
        return True
    else: 
        return False

# ––––––––––––––––––––––––––––––––

list1 = [] 

if enquiry(list1): 
    print ("The list is Empty") 
else: 
    print ("The list isn't empty") 

# Result: "The list is Empty"

Сподіваюсь, це допомагає.