Örneğin, aşağıdakileri geçtiyse:

a = []

aBoş olup olmadığını nasıl kontrol ederim ?

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

Kullanılması örtük booleanness boş ait listoldukça pythonic olduğunu.

Bunu yapmanın pythonic yolu PEP 8 stil rehberinden (burada Evet “tavsiye edilir” ve Hayır “tavsiye edilmez” anlamına gelir):

Diziler (dizeler, listeler, tuples) için boş dizilerin yanlış olduğu gerçeğini kullanın.

Yes: if not seq:
     if seq:

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

Açıkça tercih ederim:

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

Bu şekilde libir sekans (liste) olan% 100 açıktır ve boyutunu test etmek istiyoruz. Benim sorunum boolean değişkeni if not li: ...olan yanlış izlenim vermek olmasıdır li.

_{Bu, "python testi boş dizi" ve benzer sorgular için ilk google hit, artı diğer insanlar soruyu sadece listelerin ötesinde genelleştiriyor gibi görünüyor, bu yüzden birçok insanın farklı bir dizi türü için bir uyarı ekleyeceğini düşündüm kullanabilir.}

Diğer yöntemler NumPy dizileri için çalışmaz

NumPy dizilerine dikkat etmeniz gerekir, çünkü lists veya diğer standart kaplar için iyi çalışan diğer yöntemler NumPy dizileri için başarısız olur. Neden aşağıda izah ama kısacası tercih edilen yöntem kullanılmak etmektirsize .

"Pitonik" yol çalışmıyor: Bölüm 1

"Pythonic" yolu NumPy dizileriyle başarısız olur, çünkü NumPy diziyi bir bools dizisine yayınlamaya çalışır ve if xbu bools'nin tümünü bir kerede toplam doğruluk değeri için değerlendirmeye çalışır . Ama bu hiç mantıklı değil, yani 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()

"Pitonik" yol çalışmıyor: Bölüm 2

Ama en azından yukarıdaki durum bunun başarısız olduğunu söylüyor. Tam olarak bir öğeye sahip bir NumPy diziniz varsa, hata almamanız açısından ififade "çalışır". Ancak, bu bir öğe 0(veya 0.0, veya False...) ifolursa , ifade yanlış sonuç verir False:

>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x

Ama açıkça xvar ve boş değil! Bu sonuç istediğin gibi değil.

kullanma len beklenmedik sonuçlar verebilir

Örneğin,

len( numpy.zeros((1,0)) )

Dizi sıfır öğeye sahip olmasına rağmen 1 değerini döndürür.

Numpythonic yolu

SciPy SSS bölümünde açıklandığı gibi, NumPy dizisine sahip olduğunuzu bildiğiniz tüm durumlarda doğru yöntem kullanmaktır 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

Bunun listbir NumPy dizisi veya başka bir şey olup olmadığından emin değilseniz, bu yaklaşımı @dubiousjim'in verdiği yanıtla birleştirebilirsiniz. her tür için doğru testin kullanıldığından emin olmak için . Çok "pitonik" değil, ama NumPy'nin en azından bu anlamda pythonicity'yi kasıtlı olduğu ortaya çıktı.

Girişin boş olup olmadığını kontrol etmekten daha fazlasını yapmanız gerekiyorsa ve indeksleme veya matematik işlemleri gibi diğer NumPy özelliklerini kullanıyorsanız, girişi bir NumPy dizisi olmaya zorlamak muhtemelen daha etkilidir (ve kesinlikle daha yaygındır) . Bunu hızlı bir şekilde yapmak için birkaç güzel işlev var - en önemlisi numpy.asarray. Bu, girdinizi alır, zaten bir dizi ise hiçbir şey yapmaz ya da bir liste, grup vb. İse girdinizi bir diziye sarar ve isteğe bağlı olarak seçtiğinize dönüştürür dtype. Bu yüzden olabildiğince hızlıdır ve girişin bir NumPy dizisi olduğunu varsaymanızı sağlar. Bir diziye dönüştürme işlemi geçerli kapsamın dışına çıkmayacağından, genellikle aynı adı kullanırız :

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

Bu x.size, bu sayfada gördüğüm tüm durumlarda çekin çalışmasını sağlayacaktır .

Bir listenin boş olup olmadığını kontrol etmenin en iyi yolu

Örneğin, aşağıdakileri geçtiyse:

a = []

A'nın boş olup olmadığını nasıl kontrol ederim?

Kısa cevap:

Listeyi bir boole bağlamına yerleştirin (örneğin, ifveya whileifadesiyle). FalseBoş olup olmadığını test eder, Trueaksi takdirde. Örneğin:

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

PEP 8

Python'un standart kütüphanesindeki Python kodu için resmi Python stil rehberi PEP 8 şunları söylüyor:

Diziler (dizeler, listeler, tuples) için boş dizilerin yanlış olduğu gerçeğini kullanın.

Yes: if not seq:
     if seq:

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

Standart kütüphane kodunun olabildiğince performanslı ve doğru olmasını beklemeliyiz. Peki neden böyle ve neden bu rehberliğe ihtiyacımız var?

açıklama

Sık sık Python için yeni deneyimli programcılar böyle kodu görüyorum:

if len(a) == 0:                     # Don't do this!
    print('a is an empty list')

Ve tembel dillerin kullanıcıları bunu yapmaya cazip gelebilir:

if a == []:                         # Don't do this!
    print('a is an empty list')

Bunlar diğer dillerde de doğrudur. Ve bu Python'da anlamsal olarak doğrudur.

Ancak bunu Pythonic olarak düşünüyoruz, çünkü Python bu anlambilimi doğrudan liste nesnesinin arayüzünde boole zorlamasıyla destekliyor.

Gönderen docs (ve not boş listenin özellikle dahil, []):

Sınıf , nesne ile çağrıldığında, döndürülen bir yöntemi veya sıfır __bool__()döndüren bir yöntemi tanımlamazsa, varsayılan olarak bir nesne true olarak kabul edilir . Yanlış olarak kabul edilen yerleşik nesnelerin çoğu şunlardır:False__len__()

• false olarak tanımlanan sabitler: NoneveFalse .
• herhangi bir sayısal tür sıfır: 0, 0.0, 0j,Decimal(0) ,Fraction(0, 1)
• Boş diziler ve koleksiyonlar: '', (), [], {}, set(),range(0)

Ve veri modeli belgeleri:

object.__bool__(self)

Gerçeğe uygun değer testi ve yerleşik işlemi uygulamaya çağırdı bool(); dönmeli Falseya daTrue . Bu yöntem tanımlanmadığında, tanımlanmışsa __len__()çağrılır ve sonucu sıfırdan farklıysa nesne true olarak kabul edilir. Bir sınıf ne __len__() de ne de tanımlarsa __bool__(), tüm örnekleri doğru kabul edilir.

ve

object.__len__(self)

Yerleşik işlevi uygulamak için çağrıldı len() . Nesnenin uzunluğunu döndürmelidir, tamsayı> = 0. Ayrıca, bir __bool__()yöntem tanımlamayan ve __len__()yöntemi sıfıra dönen bir nesne Boole bağlamında false olarak kabul edilir.

Bunun yerine:

if len(a) == 0:                     # Don't do this!
    print('a is an empty list')

veya bu:

if a == []:                     # Don't do this!
    print('a is an empty list')

Bunu yap:

if not a:
    print('a is an empty list')

Pythonic'i yapmak genellikle performansta işe yarar:

Ödeniyor mu? (Eşdeğer bir işlem gerçekleştirmek için daha az zamanın daha iyi olduğunu unutmayın :)

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

Ölçek için, işlevi çağırmanın ve yukarıda kullanılan boşluk kontrollerinin maliyetlerinden çıkarabileceğiniz boş bir liste oluşturma ve geri gönderme maliyeti aşağıdadır:

>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342

Biz görüyoruz , ya yerleşik fonksiyonu ile uzunluğu için kontrol lenile karşılaştırıldığında 0 ya boş bir listeye karşı kontrol ediyor çok yeterli performansı belgelendiği gibi dilin yerleşik sözdizimi kullanılarak daha.

Neden?

İçin len(a) == 0 çek:

İlk önce Python'un len gölgeli .

Daha sonra işlevi çağırmalı, yüklemeli 0ve Python'da eşitlik karşılaştırmasını yapmalıdır (C yerine):

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

Ve [] == []bunun için gereksiz bir liste oluşturmalı ve sonra tekrar Python'un sanal makinesinde karşılaştırma işlemini yapmalıdır (C yerine)

>>> dis.dis(lambda: [] == [])
  1           0 BUILD_LIST               0
              2 BUILD_LIST               0
              4 COMPARE_OP               2 (==)
              6 RETURN_VALUE

Listenin uzunluğu nesne örneği üstbilgisinde önbelleğe alındığından, "Pythonic" yolu çok daha basit ve hızlı bir denetimdir:

>>> dis.dis(lambda: not [])
  1           0 BUILD_LIST               0
              2 UNARY_NOT
              4 RETURN_VALUE

C kaynağından kanıtlar ve belgeler

PyVarObject

Bu alanı PyObjectekleyen bir uzantısıdır ob_size. Bu sadece uzunluk kavramına sahip nesneler için kullanılır. Bu tür genellikle Python / C API'sinde görünmez. PyObject_VAR_HEADMakronun genişlemesi ile tanımlanan alanlara karşılık gelir .

Include / listobject.h içindeki c kaynağından :

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

Yorumlara yanıt:

Bununla olarak oldukça çirkin olsa boş olmayan durum için de geçerli olduğunu işaret etmek isterim l=[]sonra %timeit len(l) != 090.6 ns ± 8.3 ns, %timeit l != []55.6 ns ± 3,09, %timeit not not l38.5 ns ± 0.372. Ancak not not lüçlü hıza rağmen kimsenin zevk alacağı bir yol yoktur . Saçma görünüyor. Ancak hız
kazanır.Sorun if l:yeterli olduğunu, ancak şaşırtıcı bir şekilde %timeit bool(l)101 ns ± 2.64 ns verdiğinden problemin timeit ile test edildiğini düşünüyorum . İlginçtir, bu ceza olmadan boole zorlanmanın bir yolu yoktur. %timeit lhiçbir dönüşüm gerçekleşmeyeceğinden yararsızdır.

IPython büyüsü,, %timeitburada tamamen işe yaramaz:

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)

notBurada her bir ek için biraz doğrusal maliyet olduğunu görebiliriz. Maliyetleri, ceteris paribus'u , yani her şeyin eşit olduğunu görmek istiyoruz - diğer her şey mümkün olduğunca en aza indirilmiştir:

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)

Şimdi bir işsizlik listesi için duruma bakalım:

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)

Burada görebildiğimiz, gerçek bir şekilde geçip geçmemenizin çok az fark yaratmasıdır bool şey, durum kontrolüne veya listenin kendisine şekilde geçmemeniz ve listeyi olduğu gibi veren herhangi bir şeyin daha hızlı olması fark etmez.

Python C dilinde yazılmıştır; mantığını C düzeyinde kullanır. Python'da yazdığınız her şey daha yavaş olacaktır. Doğrudan Python'da yerleşik mekanizmaları kullanmadığınız sürece büyük olasılıkla daha yavaş emirler olacaktır.

Gerçek değer testinde boş bir listenin kendisi yanlış kabul edilir ( python belgelerine bakın ):

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

@Daren Thomas

EDIT: boş liste yanlış olarak test karşı başka bir nokta: Polimorfizm hakkında ne? Liste olan bir listeye bağımlı olmamalısınız. Sadece bir ördek gibi quack yapmalı - ördekinizi nasıl toplayacaksınız?

Kişisel duckCollection uygulamalıdır __nonzero__veya __len__bir eğer öyleyse: sorunsuz çalışacaktır.

Patrick'in (kabul edilen) cevabı doğrudur: if not a:bunu yapmanın doğru yolu. Harley Holcombe'un cevabı , bunun PEP 8 stil kılavuzunda olduğu doğru. Ancak cevapların hiçbirinin açıklayamadığı şey, deyimi takip etmenin neden iyi bir fikir olduğudur - kişisel olarak Ruby kullanıcıları veya herhangi bir şey için yeterince açık veya kafa karıştırıcı olmasanız bile.

Python kodu ve Python topluluğu çok güçlü deyimlere sahiptir. Bu deyimleri izlemek, Python'da deneyimli herkes için kodunuzun okunmasını kolaylaştırır. Ve bu deyimleri ihlal ettiğinizde, bu güçlü bir sinyaldir.

Bu doğrudur if not a:gelen boş listeleri ayrım yapmaz NoneFalsey ile skalerler görevi görmek veya sayısal 0 veya boş dizilerini veya boş kullanıcı tarafından oluşturulan koleksiyon türleri veya boş kullanıcı tarafından oluşturulan değil oldukça toplama türleri veya tek eleman NumPy dizi Ve bazen bu konuda açık olmak önemlidir. Ve bu durumda, ne hakkında açık olmak istediğinizi biliyorsunuz , böylece tam olarak bunu test edebilirsiniz. Örneğin, if not a and a is not None:"Hiçbiri dışında falsey olan herhangi bir şey" if len(a) != 0:anlamına gelirken , "yalnızca boş diziler - ve bir dizinin dışındaki her şey burada bir hatadır" anlamına gelir. Tam olarak ne test etmek istediğinizi test etmenin yanı sıra bu, okuyucuya bu testin önemli olduğunu da gösterir.

Ancak, açıklanacak bir şeyiniz olmadığında if not a:, okuyucuyu yanlış yönlendirmekten başka bir şey yoktur . Önemli olmadığında önemli bir şeye işaret ediyorsun. (Ayrıca kodu daha az esnek, daha yavaş veya her neyse yapıyor olabilirsiniz, ancak bunların hepsi daha az önemlidir.) Ve okuyucuyu böyle alışkanlıkla yanlış yönlendirirseniz, bir ayrım yapmanız gerektiğinde, fark edilmeden geçecektir, çünkü kodunun her yerinde "ağlayan kurt" oldun.

Neden hiç kontrol etmiyorsun?

Kimse listeyi ilk etapta test etme ihtiyacınızı sorgulamış gibi görünmüyor . Başka bir bağlam sağlamadığınız için, bu kontrolü ilk etapta yapmanız gerekmeyebileceğini, ancak Python'daki liste işlemeyi bilmediğinizi hayal edebiliyorum.

En pitonik yolun hiç kontrol etmek değil, sadece listeyi işlemek olduğunu iddia ediyorum . Bu şekilde boş veya dolu olsun doğru olanı yapar.

a = []

for item in a:
    <do something with item>

<rest of code>

Bu herhangi içeriğini ele yararı vardır bir boşluk için belirli bir çek ihtiyaç duymaz,. Eğer bir boş, bağımlı blok yürütmek olmaz ve tercüman sonraki satıra yoluyla düşecek.

Diziyi boşluk için kontrol etmeniz gerekiyorsa, diğer cevaplar yeterlidir.

len()Python listeleri, dizeler, diktler ve kümeler için O (1) işlemidir . Python, bu kaplardaki eleman sayısını dahili olarak izler.

JavaScript benzer doğruluk / falsy kavramına sahiptir .

Yazdım:

if isinstance(a, (list, some, other, types, i, accept)) and not a:
    do_stuff

-1 oylandı. Bunun okuyucuların stratejiye itiraz etmeleri veya cevabın sunulduğu gibi yardımcı olmadığını düşündüklerinden emin değilim. İkincisi gibi davranacağım, çünkü "pythonic" olarak sayılan her şey --- bu doğru stratejidir. Önceden dışlanmış değilseniz veya aörneğin davaları ele almaya hazır Falsedeğilseniz, sadece testten daha kısıtlayıcı bir teste ihtiyacınız vardır if not a:. Bunun gibi bir şey kullanabilirsiniz:

if isinstance(a, numpy.ndarray) and not a.size:
    do_stuff
elif isinstance(a, collections.Sized) and not a:
    do_stuff

ilk test yukarıdaki @ Mike'ın cevabına yanıt olarak verilmiştir. Üçüncü satır da şu şekilde değiştirilebilir:

elif isinstance(a, (list, tuple)) and not a:

yalnızca belirli türlerin (ve alt türlerinin) örneklerini kabul etmek istiyorsanız veya aşağıdakilerle:

elif isinstance(a, (list, tuple)) and not len(a):

Açık tür denetimi olmadan kurtulabilirsiniz, ancak yalnızca çevredeki içerik zaten sizi güvence altına alıyorsa, bu aişlemeye hazır olduğunuz türlerin bir değeridir veya işlemeye hazır olmadığınız türlerin gittiğinden eminseniz işlemeye hazır olduğunuz hataları (ör. tanımsız olduğu bir değeri TypeErrorçağırırsanız) yükseltmek leniçin. Genel olarak, "pitonik" konvansiyonlar bu şekilde yürüyor gibi görünüyor. Ördek gibi sıkın ve nasıl quack yapacağını bilmiyorsa bir DuckError yükseltmesine izin verin. Hala düşünmek zorundasınız hakkında ne tür varsayımlar sen yapma olsa ve düzgün gerçekten işlemek için hazır değilsin doğru yerlere dışarı hata olacak durumlarda olmadığına. Numpy dizileri sadece körü körüne güvenen iyi bir örnektirlen ya da boolean typecast tam olarak beklediğinizi yapmayabilir.

Gönderen belgelere doğruluk değeri testlere:

Burada listelenenler dışındaki tüm değerler dikkate alınır True

• None
• False
• herhangi bir sayısal tür sıfır, örneğin 0, 0.0, 0j.
• boş bir sıra, örneğin, '', (), [].
• herhangi bir boş eşleme, örneğin {}.
• sınıf bir __bool__()veya __len__()yöntemi tanımlarsa , bu yöntem tamsayı sıfır veya bool değeri döndürdüğünde, kullanıcı tanımlı sınıf örnekleri False.

Görüldüğü üzere, boş liste []olduğunu falsy , en verimli bir boolean değer seslere yapılması ne yapıyor bu yüzden:

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

Bir listenin boş olup olmadığını kontrol etmenin birkaç yolu:

a = [] #the list

1) Oldukça basit pitonik yol:

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

Python'da liste, tuples, küme, dikte, değişken vb . Gibi boş kaplar olarak görülür False. Listeyi yüklem ( Boole değeri döndüren) olarak ele almak yeterlidir . Ve bir Truedeğer boş olmadığını gösterir.

2) Çok açık bir yol: len()uzunluğu bulmak ve eşit olup olmadığını kontrol etmek için 0:

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

3) Veya isimsiz bir boş listeyle karşılaştırılması:

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

4) Bir başka henüz saçma do yolu kullanıyor exceptionve iter():

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

Aşağıdakileri tercih ederim:

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

Yöntem 1 (Tercih Edilen):

if not a : 
   print ("Empty") 

Yöntem 2:

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

Yöntem 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])

Bazen Noneiki farklı durum olduğu için boşlukları ayrı ayrı test etmek ve denemek iyi olabilir . Yukarıdaki kod aşağıdaki çıktıyı üretir:

list is None 
list is empty 
list has 3 elements

Her ne kadar bir şey Nonedeğersiz olsa da. Eğer test için Noneayrılık istemiyorsanız, bunu yapmak zorunda değilsiniz.

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

beklenen üretim

list is empty
list is empty
list has 3 elements

Birçok cevap verildi ve birçoğu oldukça iyi. Sadece çeki eklemek istedim

not a

Noneve diğer boş yapı türlerini de geçecektir . Gerçekten boş bir liste olup olmadığını kontrol etmek istiyorsanız, bunu yapabilirsiniz:

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

başka bir basit kullanabiliriz:

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

Bir listenin boş olup olmadığını kontrol etmek istiyorsanız:

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

Listedeki tüm değerlerin boş olup olmadığını kontrol etmek istiyorsanız. Ancak Trueboş bir liste olacaktır:

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

Her iki durumu da birlikte kullanmak istiyorsanız:

def empty_list(lst):
    if len(lst) == 0:
        return False
    else:
        return all(bool(x) for x in l)

Şimdi şunları kullanabilirsiniz:

if empty_list(lst):
    # do your stuff.

@ Dubiousjim'in çözümünden esinlenerek, tekrarlanabilir bir şey olup olmadığına dair ek bir genel kontrol kullanmayı öneriyorum

import collections
def is_empty(a):
    return not a and isinstance(a, collections.Iterable)

Not: Bir dize yinelenebilir olarak kabul edilir. - and not isinstance(a,(str,unicode))boş dizenin hariç tutulmasını istiyorsanız ekleyin

Ölçek:

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

biraz daha pratik:

a.pop() if a else None

ve shertest sürümü:

if a: a.pop() 

Python3'ten itibaren kullanabilirsiniz

a == []

listenin boş olup olmadığını kontrol etmek için

EDIT: Bu da python2.7 ile çalışır ..

Neden bu kadar karmaşık cevaplar olduğundan emin değilim. Oldukça açık ve anlaşılır

Hatta böyle bool () kullanmayı deneyebilirsiniz

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

Kontrol listesi boş ya da değil için bu şekilde seviyorum.

Çok kullanışlı ve kullanışlı.

Sadece is_empty () kullanın ya da aşağıdaki gibi bir işlev yapın: -

def is_empty(any_structure):
    if any_structure:
        print('Structure is not empty.')
        return True
    else:
        print('Structure is empty.')
        return False  

Liste, tuples, sözlük ve daha fazlası gibi herhangi bir veri yapısı için kullanılabilir. Bunlarla, sadece kullanarak birçok kez arayabilirsiniz is_empty(any_structure).

Basit yolu uzunluğu eşit sıfır kontrol etmektir.

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

Boş bir listenin gerçek değeri, boş Falseolmayan bir liste için doğrudur True.

Beni buraya getiren özel bir kullanım durumu: Aslında bir listenin boş olup olmadığını söylemek için bir işlev istedim . Kendi işlevimi yazmaktan veya burada bir lambda ifadesi kullanmaktan kaçınmak istedim (çünkü yeterince basit görünüyordu):

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

Ve elbette, bunu yapmanın çok doğal bir yolu var:

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

Tabii ki, do not kullanmak booliçinde if(yani if bool(L):o ima çünkü). Ancak, bir işlev olarak "boş olmayan" açıkça ihtiyaç duyulan durumlarda bool, en iyi seçimdir.

Bir listenin boş olup olmadığını kontrol etmek için aşağıdaki iki yolu kullanabilirsiniz. Ancak unutmayın, bir tür sekansı açıkça kontrol etmekten kaçınmalıyız (bu bir less pythonicyol):

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

İkinci yol more pythonicbirdir. Bu yöntem, örtük bir kontrol yöntemidir ve öncekinden çok daha fazla tercih edilir.

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"

Bu yardımcı olur umarım.